class BattleshipMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="battleship",
family_version="1.0",
namespace=MessageFactory.sha512("battleship".encode("utf-8"))[0:6],
signer=signer
)
def _game_to_address(self, game):
return self._factory.namespace + \
self._factory.sha512(game.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, payload):
addresses = [self._game_to_address(payload['Name'])]
return txn_function(
json.dumps(payload).encode(),
addresses,
addresses,
[])
def create_tp_process_request(self, payload):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, payload)
def create_transaction(self, payload):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, payload)
def create_get_request(self, name):
addresses = [self._game_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, game, payload=None):
if payload:
address = self._game_to_address(game)
data = json.dumps({game: payload}).encode()
return self._factory.create_get_response({address: data})
return self._factory.create_get_response({})
def create_set_request(self, game, new_state):
address = self._game_to_address(game)
data = json.dumps({game: new_state}).encode()
return self._factory.create_set_request({address: data})
def create_set_response(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class BattleshipMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(family_name="battleship",
family_version="1.0",
namespace=MessageFactory.sha512(
"battleship".encode("utf-8"))[0:6],
private=private,
public=public)
def _game_to_address(self, game):
return self._factory.namespace + \
self._factory.sha512(game.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, payload):
addresses = [self._game_to_address(payload['Name'])]
return txn_function(
json.dumps(payload).encode(), addresses, addresses, [])
def create_tp_process_request(self, payload):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, payload)
def create_transaction(self, payload):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, payload)
def create_get_request(self, name):
addresses = [self._game_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, game, payload=None):
if payload:
address = self._game_to_address(game)
data = json.dumps({game: payload}).encode()
return self._factory.create_get_response({address: data})
return self._factory.create_get_response({})
def create_set_request(self, game, new_state):
address = self._game_to_address(game)
data = json.dumps({game: new_state}).encode()
return self._factory.create_set_request({address: data})
def create_set_response(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class SettingMessageFactory(object):
def __init__(self, signer=None):
self._asset_addr = Address(Address.FAMILY_ASSET)
self._setting_addr = Address(Address.FAMILY_SETTING)
self._factory = MessageFactory(
family_name=Address.NAMESPACE_SETTING,
family_version="0.1.0",
namespace=[self._setting_addr.ns_family],
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, dimension, payload):
address = self._setting_addr.settings(dimension)
inputs = [address, self._asset_addr.candidates(dimension)]
outputs = [address, self._asset_addr.candidates(dimension)]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_payload_request(self, settings, dimension, action):
payload = SettingPayload(action=action,
dimension=dimension,
data=settings.SerializeToString())
return self._create_tp_process_request(dimension, payload)
def create_setting_transaction(self, auth_keys, thresh, dimension, action):
setting = Settings(auth_list=auth_keys, threshold=thresh)
return self.create_payload_request(setting, dimension, action)
def create_get_request(self, address):
return self._factory.create_get_request([address])
def create_get_response(self, address, data=None):
return self._factory.create_get_response({address: data})
def create_set_request(self, address, setting=None):
return self._factory.create_set_request({address: setting})
def create_set_response(self, address):
return self._factory.create_set_response([address])
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"hashblock.setting/update", [("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class MktMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(family_name="mkt",
family_version="1.0",
namespace=MessageFactory.sha512(
"mkt".encode("utf-8"))[0:6],
signer=signer)
def _house_to_address(self, house):
return self._factory.namespace + \
self._factory.sha512(house.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, house, action, owner):
payload = ",".join([str(house), str(action), str(owner)]).encode()
addresses = [self._house_to_address(house)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, house, owner):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, house, action, owner)
def create_transaction(self, house, action, owner):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, house, action, owner)
def create_get_request(self, house):
addresses = [self._house_to_address(house)]
return self._factory.create_get_request(addresses)
def create_get_response(self, house, owner):
address = self._house_to_address(house)
data = ",".join([house, owner]).encode()
return self._factory.create_get_response({address: data})
def create_set_request(self, house, owner):
address = self._house_to_address(house)
data = ",".join([house, owner]).encode()
return self._factory.create_set_request({address: data})
def create_set_response(self, house):
addresses = [self._house_to_address(house)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class SettingsMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="sawtooth_settings",
family_version="1.0",
namespace="000000",
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
key_parts = key.split('.', maxsplit=_MAX_KEY_PARTS - 1)
key_parts.extend([''] * (_MAX_KEY_PARTS - len(key_parts)))
def _short_hash(in_str):
return self._factory.sha256(in_str.encode())[:16]
return self._factory.namespace + \
''.join(_short_hash(x) for x in key_parts)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, setting, payload):
inputs = [
self._key_to_address('sawtooth.settings.vote.proposals'),
self._key_to_address('sawtooth.settings.vote.authorized_keys'),
self._key_to_address('sawtooth.settings.vote.approval_threshold'),
self._key_to_address(setting)
]
outputs = [
self._key_to_address('sawtooth.settings.vote.proposals'),
self._key_to_address(setting)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, setting, value, nonce):
proposal = SettingProposal(setting=setting, value=value, nonce=nonce)
payload = SettingsPayload(action=SettingsPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_vote_proposal(self, proposal_id, setting, vote):
vote = SettingVote(proposal_id=proposal_id, vote=vote)
payload = SettingsPayload(action=SettingsPayload.VOTE,
data=vote.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_get_request(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_get_request(addresses)
def create_get_response(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_set_response(addresses)
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"settings/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class ConfigMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding="application/protobuf",
family_name="sawtooth_config",
family_version="1.0",
namespace="000000",
private=private,
public=public
)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, setting, payload):
inputs = [
self._key_to_address('sawtooth.config.authorization_type'),
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address('sawtooth.config.vote.authorized_keys'),
self._key_to_address('sawtooth.config.vote.approval_threshold'),
self._key_to_address(setting)
]
outputs = [
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address(setting)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, setting, value, nonce):
proposal = ConfigProposal(setting=setting, value=value, nonce=nonce)
payload = ConfigPayload(action=ConfigPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_vote_proposal(self, proposal_id, setting, vote):
vote = ConfigVote(proposal_id=proposal_id, vote=vote)
payload = ConfigPayload(action=ConfigPayload.VOTE,
data=vote.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_get_request(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_get_request(addresses)
def create_get_response(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_set_response(addresses)
class SettingsMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="bgx_settings",
family_version="1.0",
namespace="000000",
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
key_parts = key.split('.', maxsplit=_MAX_KEY_PARTS - 1)
key_parts.extend([''] * (_MAX_KEY_PARTS - len(key_parts)))
def _short_hash(in_str):
return self._factory.sha256(in_str.encode())[:16]
return self._factory.namespace + \
''.join(_short_hash(x) for x in key_parts)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, setting, payload):
inputs = [
self._key_to_address('sawtooth.settings.vote.proposals'),
self._key_to_address('sawtooth.settings.vote.authorized_keys'),
self._key_to_address('sawtooth.settings.vote.approval_threshold'),
self._key_to_address(setting)
]
outputs = [
self._key_to_address('sawtooth.settings.vote.proposals'),
self._key_to_address(setting)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, setting, value, nonce):
proposal = SettingProposal(setting=setting, value=value, nonce=nonce)
payload = SettingsPayload(action=SettingsPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_vote_proposal(self, proposal_id, setting, vote):
vote = SettingVote(proposal_id=proposal_id, vote=vote)
payload = SettingsPayload(action=SettingsPayload.VOTE,
data=vote.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_get_request(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_get_request(addresses)
def create_get_response(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_set_response(addresses)
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"settings/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class VotingMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(family_name='voting',
family_version='1.0',
namespace=VOTING_ADDRESS_PREFIX,
signer=signer)
def _dumps(self, obj):
return cbor.dumps(obj, sort_keys=True)
def _loads(self, data):
return cbor.loads(data)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, verb, name, value):
payload = self._dumps({'Verb': verb, 'Name': name, 'Value': value})
addresses = [make_voting_address(name)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(
self,
verb,
name,
value,
):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, verb, name, value)
def create_transaction(
self,
verb,
name,
value,
):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, verb, name, value)
def create_batch(self, triples):
txns = [
self.create_transaction(verb, name, value)
for verb, name, value in triples
]
return self._factory.create_batch(txns)
def create_get_request(self, name):
addresses = [make_voting_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name, value):
address = make_voting_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, name, value):
address = make_voting_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name):
addresses = [make_voting_address(name)]
return self._factory.create_set_response(addresses)
class SupplychainMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding='application/protobuf',
family_name=SUPPLYCHAIN_FAMILY_NAME,
family_version=SUPPLYCHAIN_VERSION,
namespace=[Addressing.agent_namespace(),
Addressing.application_namespace(),
Addressing.record_namespace()],
private=private,
public=public
)
@property
def public_key(self):
return self._factory.get_public_key()
def _dumps(self, obj):
if obj is not None:
return obj.SerializeToString()
return None
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, txn, inputs=None, outputs=None):
payload = self._dumps(txn)
return txn_function(payload, inputs, outputs, [])
def create_tp_process_request(self, action, data=None,
inputs=None, outputs=None):
payload = SupplyChainPayload(action=action, data=self._dumps(data))
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, payload, inputs, outputs)
def create_get_request(self, addresses):
return self._factory.create_get_request(addresses)
def create_get_response(self, items):
response = OrderedDict()
for (addr, value) in items:
data = None
if value is not None:
data = self._dumps(self._containerize(value))
response[addr] = data
return self._factory.create_get_response(response)
def create_set_request(self, items):
response = OrderedDict()
for (addr, value) in items:
data = None
if value is not None:
data = self._dumps(self._containerize(value))
response[addr] = data
return self._factory.create_set_request(response)
def create_set_response(self, addresses):
return self._factory.create_set_response(addresses)
@staticmethod
def _containerize(value):
if isinstance(value, Agent):
return AgentContainer(entries=[value])
elif isinstance(value, Application):
return ApplicationContainer(entries=[value])
elif isinstance(value, Record):
return RecordContainer(entries=[value])
raise Exception("Unknown data type")
def create_agent_tp_process_request(self, name):
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
inputs = [agent_addr]
outputs = [agent_addr]
return self.create_tp_process_request(
SupplyChainPayload.AGENT_CREATE,
AgentCreatePayload(name="agent"),
inputs, outputs)
def create_record_tp_process_request(self,
identifier,
timestamp):
record_addr = Addressing.record_address(identifier)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
inputs = [agent_addr, record_addr]
outputs = [agent_addr, record_addr]
return self.create_tp_process_request(
SupplyChainPayload.RECORD_CREATE,
RecordCreatePayload(identifier=identifier,
creation_time=timestamp),
inputs, outputs)
def finalize_record_tp_process_request(self,
record_id):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
inputs = [agent_addr, record_addr]
outputs = [agent_addr, record_addr]
return self.create_tp_process_request(
SupplyChainPayload.RECORD_FINALIZE,
RecordFinalizePayload(identifier=record_id),
inputs, outputs)
def create_application_tp_process_request(self,
agent_pub_key,
record_id,
timestamp,
application_type,
terms=None):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
inputs = [agent_addr, record_addr]
outputs = [record_addr]
return self.create_tp_process_request(
SupplyChainPayload.APPLICATION_CREATE,
ApplicationCreatePayload(record_identifier=record_id,
creation_time=timestamp,
type=application_type,
terms=terms),
inputs, outputs)
def create_application_accept_tp_process_request(self,
record_id,
applicant_id,
application_type,
timestamp=0):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
inputs = [agent_addr, record_addr]
outputs = [record_addr]
return self.create_tp_process_request(
SupplyChainPayload.APPLICATION_ACCEPT,
ApplicationAcceptPayload(record_identifier=record_id,
applicant=applicant_id,
type=application_type,
timestamp=timestamp),
inputs, outputs)
def create_application_reject_tp_process_request(self,
record_id,
applicant_id,
application_type):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
application_addr = Addressing.application_address(record_id)
inputs = [agent_addr, application_addr, record_addr]
outputs = [application_addr]
return self.create_tp_process_request(
SupplyChainPayload.APPLICATION_REJECT,
ApplicationRejectPayload(record_identifier=record_id,
applicant=applicant_id,
type=application_type),
inputs, outputs)
def create_application_cancel_tp_process_request(self,
record_id,
applicant_id,
application_type):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
application_addr = Addressing.application_address(record_id)
inputs = [agent_addr, application_addr, record_addr]
outputs = [application_addr]
return self.create_tp_process_request(
SupplyChainPayload.APPLICATION_CANCEL,
ApplicationCancelPayload(record_identifier=record_id,
applicant=applicant_id,
type=application_type),
inputs, outputs)
def create_agent(self, identifier, name=None):
agent = Agent(identifier=identifier)
if name:
agent.name = name
return agent
def create_record(self, identifier, timestamp=0,
owners=None, custodians=None, final=False):
return Record(
identifier=identifier,
creation_time=timestamp,
owners=owners or [],
custodians=custodians or [],
final=False)
def add_agent_record(self, field, pub_key, timestamp=0):
record = field.add()
record.agent_identifier = pub_key
record.start_time = timestamp
def create_application(self, record_id, agent_pub_key, application_type,
status, timestamp=0, terms=None):
return Application(
record_identifier=record_id,
applicant=agent_pub_key,
creation_time=timestamp,
type=application_type,
status=status,
terms=terms)
class SimplewalletMessageFactory(object):
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="carLogger",
family_version="1.0",
namespace=MessageFactory.sha512("carLogger".encode("utf-8"))[0:6],
signer=signer)
def get_public_key(self):
return self._factory.get_public_key()
def _make_address(self):
return self._factory.namespace + \
self._factory.sha512(get_public_key())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, action, value=None):
payload = ",".join([
str(action), str(value)
]).encode()
addresses = [self._make_address()]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, value=None):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, action, value)
def create_transaction(self, action, value=None):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, action, value)
def create_get_request(self):
addresses = [self._make_address()]
return self._factory.create_get_request(addresses)
def create_set_request(self, value):
address = self._make_address()
data = None
if value is not None:
data = str(value).encode()
else:
data = None
return self._factory.create_set_request({address: data})
def create_get_response(self, value):
address = self._make_address()
data = None
if value is not None:
data = str(value).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_response(self, game):
addresses = [self._make_address()]
return self._factory.create_set_response(addresses)
class XoMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="xo",
family_version="1.0",
namespace=MessageFactory.sha512("xo".encode("utf-8"))[0:6],
signer=signer)
def _game_to_address(self, game):
return self._factory.namespace + \
self._factory.sha512(game.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, game, action, space=None):
payload = ",".join([
str(game), str(action), str(space)
]).encode()
addresses = [self._game_to_address(game)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, game, space=None):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, game, action, space)
def create_transaction(self, game, action, space=None):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, game, action, space)
def create_get_request(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_get_request(addresses)
def create_get_response(
self, game, board="---------", state="P1-NEXT", player1="", player2=""
):
address = self._game_to_address(game)
data = None
if board is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(
self, game, board="---------", state="P1-NEXT", player1="", player2=""
):
address = self._game_to_address(game)
data = None
if state is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class ConfigMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="application/protobuf",
family_name="sawtooth_config",
family_version="1.0",
namespace="000000",
private=private,
public=public)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, setting, payload):
inputs = [
self._key_to_address('sawtooth.config.authorization_type'),
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address('sawtooth.config.vote.authorized_keys'),
self._key_to_address('sawtooth.config.vote.approval_threshold'),
self._key_to_address(setting)
]
outputs = [
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address(setting)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, setting, value, nonce):
proposal = ConfigProposal(setting=setting, value=value, nonce=nonce)
payload = ConfigPayload(action=ConfigPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_vote_proposal(self, proposal_id, setting, vote):
vote = ConfigVote(proposal_id=proposal_id, vote=vote)
payload = ConfigPayload(action=ConfigPayload.VOTE,
data=vote.SerializeToString())
return self._create_tp_process_request(setting, payload)
def create_get_request(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_get_request(addresses)
def create_get_response(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_set_response(addresses)
class IdentityMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="sawtooth_identity",
family_version="1.0",
namespace="00001d",
signer=signer,
)
@property
def public_key(self):
return self._factory.get_public_key()
def _to_hash(self, value):
return hashlib.sha256(value.encode()).hexdigest()
def _role_to_address(self, role_name):
# split the key into 4 parts, maximum
key_parts = role_name.split('.', maxsplit=_MAX_KEY_PARTS - 1)
# compute the short hash of each part
addr_parts = [self._to_hash(key_parts[0])[:_FIRST_ADDRESS_PART_SIZE]]
addr_parts += [
self._to_hash(x)[:_ADDRESS_PART_SIZE] for x in key_parts[1:]
]
# pad the parts with the empty hash, if needed
addr_parts.extend([_EMPTY_PART] * (_MAX_KEY_PARTS - len(addr_parts)))
return self._factory.namespace + _ROLE_PREFIX + ''.join(addr_parts)
def _policy_to_address(self, policy_name):
return self._factory.namespace + _POLICY_PREFIX + \
self._to_hash(policy_name)[:62]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, payload):
inputs = []
outputs = []
if payload.type == IdentityPayload.ROLE:
role = Role()
role.ParseFromString(payload.data)
inputs = [
self._role_to_address(role.name),
self._policy_to_address(role.policy_name)
]
outputs = [self._role_to_address(role.name)]
else:
policy = Policy()
policy.ParseFromString(payload.data)
inputs = [self._policy_to_address(policy.name)]
outputs = [self._role_to_address(policy.name)]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_policy_transaction(self, name, rules):
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[1])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[1])
entries.append(entry)
policy = Policy(name=name, entries=entries)
payload = IdentityPayload(type=IdentityPayload.POLICY,
data=policy.SerializeToString())
return self._create_tp_process_request(payload)
def create_role_transaction(self, name, policy_name):
role = Role(name=name, policy_name=policy_name)
payload = IdentityPayload(type=IdentityPayload.ROLE,
data=role.SerializeToString())
return self._create_tp_process_request(payload)
def create_get_policy_request(self, name):
addresses = [self._policy_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_policy_response(self, name, rules=None):
data = None
if rules is not None:
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[0])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[0])
entries.append(entry)
policy = Policy(name=name, entries=entries)
policy_list = PolicyList(policies=[policy])
data = policy_list.SerializeToString()
return self._factory.create_get_response(
{self._policy_to_address(name): data})
def create_get_role_request(self, name):
addresses = [self._role_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_role_response(self, name, policy_name=None):
data = None
if policy_name is not None:
role = Role(name=name, policy_name=policy_name)
role_list = RoleList(roles=[role])
data = role_list.SerializeToString()
return self._factory.create_get_response({
self._role_to_address(name): data})
def create_set_policy_request(self, name, rules=None):
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[1])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[1])
entries.append(entry)
policy = Policy(name=name, entries=entries)
policy_list = PolicyList(policies=[policy])
return self._factory.create_set_request({
self._policy_to_address(name): policy_list.SerializeToString()})
def create_set_policy_response(self, name):
addresses = [self._policy_to_address(name)]
return self._factory.create_set_response(addresses)
def create_set_role_request(self, name, policy_name):
role = Role(name=name, policy_name=policy_name)
role_list = RoleList(roles=[role])
return self._factory.create_set_request({
self._role_to_address(name): role_list.SerializeToString()})
def create_set_role_response(self, name):
addresses = [self._role_to_address(name)]
return self._factory.create_set_response(addresses)
def create_get_setting_request(self, key):
addresses = [key]
return self._factory.create_get_request(addresses)
def create_get_setting_response(self, key, allowed):
if allowed:
entry = Setting.Entry(
key="sawtooth.identity.allowed_keys",
value=self.public_key)
data = Setting(entries=[entry]).SerializeToString()
else:
entry = Setting.Entry(
key="sawtooth.identity.allowed_keys",
value="")
data = Setting(entries=[entry]).SerializeToString()
return self._factory.create_get_response({key: data})
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"identity/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class StakeMessageFactory(object):
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="stake",
family_version="1.0",
namespace="807062",
signer=signer,
)
@property
def public_key(self):
return self._factory.get_public_key()
def _to_hash(self, value):
return hashlib.sha256(value.encode()).hexdigest()
# TODO refactor into key_to_address for clarity
def _stake_to_address(self, owner_pub):
addr_part = self._to_hash(owner_pub)[:_ADDRESS_PART_SIZE]
return self._factory.namespace + _DEFAULT_TYPE_PREFIX + addr_part
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, payload):
inputs = []
outputs = []
if payload.payload_type == StakePayload.SEND_STAKE:
send = payload.send
inputs = [
# the stake address `from`
self._stake_to_address(self._factory.get_public_key()),
# the stake address `to`
self._stake_to_address(send.toPubKey)
]
outputs = [
# the stake address `from`
self._stake_to_address(self._factory.get_public_key()),
# the stake address `to`
self._stake_to_address(send.toPubKey)
]
elif payload.payload_type == StakePayload.LOCK_STAKE:
lock = payload.lock
inputs = [self._stake_to_address(self._factory.get_public_key())]
outputs = [self._stake_to_address(self._factory.get_public_key())]
# MINT_STAKE
else:
# Extract the payload from create_mint_stake_transaction, will need to extract
# the pub keys for ICO
mint = payload.mint
inputs = [self._stake_to_address(self._factory.get_public_key())]
outputs = [self._stake_to_address(self._factory.get_public_key())]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_mint_stake_transaction(self, total_supply: float,
mint_key: str):
mint = MintStakeTransactionData()
mint.totalSupply = total_supply
mint.ico[mint_key] = total_supply
payload = StakePayload(payload_type=StakePayload.MINT_STAKE, mint=mint)
return self._create_tp_process_request(payload)
def create_lock_stake_transaction(self, block_number: int):
lock = LockStakeTransactionData()
lock.blockNumber = block_number
payload = StakePayload(payload_type=StakePayload.LOCK_STAKE, lock=lock)
return self._create_tp_process_request(payload)
def create_send_stake_transaction(self, to_public_key, stake_amount):
send = SendStakeTransactionData()
send.toPubKey = to_public_key
send.value = stake_amount
payload = StakePayload(payload_type=StakePayload.SEND_STAKE, send=send)
return self._create_tp_process_request(payload)
def create_mint_stake_request(self, total_supply, public_key):
stake_list = self.create_stake(owner_key=public_key,
value=total_supply,
block_number=1,
nonce=1)
return self._factory.create_set_request({
self._stake_to_address(public_key):
stake_list.SerializeToString()
})
def create_mint_stake_response(self, key):
stake_addr = [self._stake_to_address(key)]
return self._factory.create_set_response(stake_addr)
def create_set_stake_request(self, public_key, stake=None):
stake_list = self.create_stake(stake=stake)
return self._factory.create_set_request({
self._stake_to_address(public_key):
stake_list.SerializeToString()
})
def create_set_stake_response(self, public_key):
addresses = [self._stake_to_address(public_key)]
return self._factory.create_set_response(addresses)
def create_get_stake_request(self, public_key):
addresses = [self._stake_to_address(public_key)]
return self._factory.create_get_request(addresses)
def create_get_stake_response(self, pub_key, stake=None):
data = None
if stake is not None:
data = self.create_stake(stake=stake)
return self._factory.create_get_response(
{self._stake_to_address(pub_key): data.SerializeToString()})
def create_set_lock_request(self, name, policy_name):
pass
def create_set_lock_response(self, name):
pass
def create_get_setting_request(self, key):
addresses = [key]
return self._factory.create_get_request(addresses)
def create_get_setting_response(self, key, allowed):
if allowed:
entry = Setting.Entry(key="sawtooth.stake.allowed_keys",
value=self.public_key)
data = Setting(entries=[entry]).SerializeToString()
else:
entry = Setting.Entry(key="sawtooth.stake.allowed_keys", value="")
data = Setting(entries=[entry]).SerializeToString()
return self._factory.create_get_response({key: data})
def create_add_event_request(self, key):
return self._factory.create_add_event_request("stake/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
def create_config(self,
latest_block,
oldest_block=None,
target_count=DEFAULT_TARGET_COUNT,
sync_tolerance=DEFAULT_SYNC_TOLERANCE):
if oldest_block is None:
oldest_block = latest_block - DEFAULT_TARGET_COUNT
return BlockInfoConfig(latest_block=latest_block,
oldest_block=oldest_block,
target_count=target_count,
sync_tolerance=sync_tolerance)
def create_stake(self,
owner_key=None,
value=None,
block_number=None,
nonce=None,
stake=None):
# if there is already a stake list
if stake is not None:
return stake
# there is no state at the address.
else:
stake_list = StakeList()
stake_list.stakeMap.get_or_create(owner_key)
stake_list.stakeMap[owner_key].ownerPubKey = owner_key
stake_list.stakeMap[owner_key].nonce = nonce
stake_list.stakeMap[owner_key].blockNumber = block_number
stake_list.stakeMap[owner_key].value = value
return stake_list
def create_get_block_config_request(self):
return self._factory.create_get_request(addresses=[CONFIG_ADDRESS])
def create_get_block_config_response(self, msg):
if msg:
# block_config.ParseFromString(bc[0].data)
config_key = next(iter(msg))
config_data = BlockInfoConfig()
config_data.ParseFromString(msg[config_key])
data = self.create_config(config_data.latest_block, oldest_block=1)
#conf = self.create_config(config.latest_block, oldest_block=1)
#data = config.SerializeToString()
else:
data = None
return self._factory.create_get_response(
{CONFIG_ADDRESS: data.SerializeToString()})
class EventMessageFactory(object):
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name=FAMILY_NAME,
family_version="0.1.0",
namespace=[EVENTS_ADDRESS_PREFIX],
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
key_parts = key.split('.', maxsplit=_MAX_KEY_PARTS - 1)
key_parts.extend([''] * (_MAX_KEY_PARTS - len(key_parts)))
def _short_hash(in_str):
return self._factory.sha256(in_str.encode())[:16]
return self._factory.namespace + \
''.join(_short_hash(x) for x in key_parts)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, code, payload):
inputs = [
self._key_to_address('hashblock.events.initiate'),
self._key_to_address('hashblock.events.reciprocate'),
self._key_to_address(code)
]
outputs = [
self._key_to_address('hashblock.events.initiate'),
self._key_to_address('hashblock.events.reciprocate'),
self._key_to_address(code)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_initiate_transaction(
self, code, version, plus,
minus, quantity, nonce):
initiate = InitiateEvent(
version=version, plus=plus,
minus=minus, nonce=nonce)
payload = EventPayload(
action=EventPayload.INITIATE_EVENT,
data=initiate.SerializeToString())
return self._create_tp_process_request(code, payload)
def create_reciprocate_transaction(self, proposal_id, code, vote):
vote = ReciprocateEvent(proposal_id=proposal_id, vote=vote)
payload = EventPayload(
action=EventPayload.RECIPROCATE_EVENT,
data=vote.SerializeToString())
return self._create_tp_process_request(code, payload)
def create_get_request(self, code):
addresses = [self._key_to_address(code)]
return self._factory.create_get_request(addresses)
def create_get_response(self, code, value=None):
address = self._key_to_address(code)
if value is not None:
entry = Unit.Entry(key=code, value=value)
data = Unit(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, code, value=None):
address = self._key_to_address(code)
if value is not None:
entry = Unit.Entry(key=code, value=value)
data = Unit(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, code):
addresses = [self._key_to_address(code)]
return self._factory.create_set_response(addresses)
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"events/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class ValidatorRegistryMessageFactory(object):
__REPORT_PRIVATE_KEY_PEM__ = \
'-----BEGIN PRIVATE KEY-----\n' \
'MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCsy/NmLwZP6Uj0\n' \
'p5mIiefgK8VOK7KJ34g3h0/X6aFOd/Ff4j+e23wtQpkxsjVHWLM5SjElGhfpVDhL\n' \
'1WAMsQI9bpCWR4sjV6p7gOJhv34nkA2Grj5eSHCAJRQXCl+pJ9dYIeKaNoaxkdtq\n' \
'+Xme//ohtkkv/ZjMTfsjMl0RLXokJ+YhSuTpNSovRaCtZfLB5MihVJuV3Qzb2ROh\n' \
'KQxcuyPy9tBtOIrBWJaFiXOLRxAijs+ICyzrqUBbRfoAztkljIBx9KNItHiC4zPv\n' \
'o6DxpGSO2yMQSSrs13PkfyGWVZSgenEYOouEz07X+H5B29PPuW5mCl4nkoH3a9gv\n' \
'rI6VLEx9AgMBAAECggEAImfFge4RCq4/eX85gcc7pRXyBjuLJAqe+7d0fWAmXxJg\n' \
'vB+3XTEEi5p8GDoMg7U0kk6kdGe6pRnAz9CffEduU78FCPcbzCCzcD3cVWwkeUok\n' \
'd1GQV4OC6vD3DBNjsrGdHg45KU18CjUphCZCQhdjvXynG+gZmWxZecuYXkg4zqPT\n' \
'LwOkcdWBPhJ9CbjtiYOtKDZbhcbdfnb2fkxmvnAoz1OWNfVFXh+x7651FrmL2Pga\n' \
'xGz5XoxFYYT6DWW1fL6GNuVrd97wkcYUcjazMgunuUMC+6XFxqK+BoqnxeaxnsSt\n' \
'G2r0sdVaCyK1sU41ftbEQsc5oYeQ3v5frGZL+BgrYQKBgQDgZnjqnVI/B+9iarx1\n' \
'MjAFyhurcKvFvlBtGKUg9Q62V6wI4VZvPnzA2zEaR1J0cZPB1lCcMsFACpuQF2Mr\n' \
'3VDyJbnpSG9q05POBtfLjGQdXKtGb8cfXY2SwjzLH/tvxHm3SP+RxvLICQcLX2/y\n' \
'GTJ+mY9C6Hs6jIVLOnMWkRWamQKBgQDFITE3Qs3Y0ZwkKfGQMKuqJLRw29Tyzw0n\n' \
'XKaVmO/pEzYcXZMPBrFhGvdmNcJLo2fcsmGZnmit8RP4ChwHUlD11dH1Ffqw9FWc\n' \
'387i0chlE5FhQPirSM8sWFVmjt2sxC4qFWJoAD/COQtKHgEaVKVc4sH/yRostL1C\n' \
'r+7aWuqzhQKBgQDcuC5LJr8VPGrbtPz1kY3mw+r/cG2krRNSm6Egj6oO9KFEgtCP\n' \
'zzjKQU9E985EtsqNKI5VdR7cLRLiYf6r0J6j7zO0IAlnXADP768miUqYDuRw/dUw\n' \
'JsbwCZneefDI+Mp325d1/egjla2WJCNqUBp4p/Zf62f6KOmbGzzEf6RuUQKBgG2y\n' \
'E8YRiaTOt5m0MXUwcEZk2Hg5DF31c/dkalqy2UYU57aPJ8djzQ8hR2x8G9ulWaWJ\n' \
'KiCm8s9gaOFNFt3II785NfWxPmh7/qwmKuUzIdWFNxAsbHQ8NvURTqyccaSzIpFO\n' \
'hw0inlhBEBQ1cB2r3r06fgQNb2BTT0Itzrd5gkNVAoGBAJcMgeKdBMukT8dKxb4R\n' \
'1PgQtFlR3COu2+B00pDyUpROFhHYLw/KlUv5TKrH1k3+E0KM+winVUIcZHlmFyuy\n' \
'Ilquaova1YSFXP5cpD+PKtxRV76Qlqt6o+aPywm81licdOAXotT4JyJhrgz9ISnn\n' \
'J13KkHoAZ9qd0rX7s37czb3O\n' \
'-----END PRIVATE KEY-----'
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding="application/protobuf",
family_name="sawtooth_validator_registry",
family_version="1.0",
namespace="6a4372",
private=private,
public=public)
self.pubkey_hash = hashlib.sha256(public.encode()).hexdigest()
self._report_private_key = \
serialization.load_pem_private_key(
self.__REPORT_PRIVATE_KEY_PEM__.encode(),
password=None,
backend=backends.default_backend())
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
# Utility function for creating proof data as we need to be
# able to update signatures when verification report changes
# Returns a serialized proof data
def create_proof_data(self, verification_report, evidence_payload):
verification_report_json = json.dumps(verification_report)
signature = \
self._report_private_key.sign(
verification_report_json.encode(),
padding.PKCS1v15(),
hashes.SHA256())
proof_data_dict = {
'evidence_payload': evidence_payload,
'verification_report': verification_report_json,
'signature': base64.b64encode(signature).decode()
}
return json.dumps(proof_data_dict)
# Currently this is done in the enclave
def create_signup_info(self, originator_public_key_hash,
most_recent_wait_certificate_id):
# First we need to create a public/private key pair for the PoET
# enclave to use.
poet_private_key = \
"1f70fa2518077ad18483f48e77882d11983b537fa5f7cf158684d2c670fe4f1f"
poet_public_key = \
signing.generate_pubkey(poet_private_key)
# currently not used
# _active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key': signing.encode_pubkey(poet_public_key, 'hex'),
'poet_private_key': signing.encode_privkey(poet_private_key, 'hex')
}
# Create a fake report
report_data = '{0}{1}'.format(
originator_public_key_hash.upper(),
signing.encode_pubkey(poet_public_key, 'hex').upper())
quote = {
'report_body':
hashlib.sha256(json.dumps(report_data).encode()).hexdigest()
}
# Create a fake PSE manifest. A base64 encoding of the
# originator public key hash should suffice.
pse_manifest = \
base64.b64encode(originator_public_key_hash.encode())
timestamp = '2017-02-16T15:21:24.437048'
# Fake our "proof" data.
verification_report = {
'epidPseudonym':
originator_public_key_hash,
'id':
base64.b64encode(
hashlib.sha256(
timestamp.encode()).hexdigest().encode()).decode(),
'isvEnclaveQuoteStatus':
'OK',
'isvEnclaveQuoteBody':
base64.b64encode(json.dumps(quote).encode()).decode(),
'pseManifestStatus':
'OK',
'pseManifestHash':
base64.b64encode(
hashlib.sha256(pse_manifest).hexdigest().encode()).decode(),
'nonce':
most_recent_wait_certificate_id,
'timestamp':
timestamp
}
proof_data = \
self.create_proof_data(
verification_report=verification_report,
evidence_payload={
'pse_manifest': pse_manifest.decode()
})
return \
SignUpInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
anti_sybil_id=originator_public_key_hash)
def create_tp_process_request(self, validator_id, payload):
inputs = [self._key_to_address('validator_list')]
outputs = [
self._key_to_address('validator_list'),
self._key_to_address(validator_id)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_get_request_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_get_request(addresses)
def create_get_response_validator_info(self, validator_name):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(registered="registered",
name=validator_name,
id=self.public_key,
signup_info=signup_info,
block_num=0).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_get_response({address: data})
def create_set_request_validator_info(self, validator_name, reg):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(registered=reg,
name=validator_name,
id=self.public_key,
signup_info=signup_info,
block_num=0).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_set_request({address: data})
def create_set_response_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_set_response(addresses)
def create_get_request_validator_map(self):
address = self._key_to_address("validator_map")
addresses = [address]
return self._factory.create_get_request(addresses)
def create_get_empty_resposne_validator_map(self):
address = self._key_to_address("validator_map")
data = ValidatorMap().SerializeToString()
return self._factory.create_get_response({address: data})
def create_get_response_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_get_response({address: data})
def create_set_request_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_set_request({address: data})
def create_set_response_validator_map(self):
addresses = [self._key_to_address("validator_map")]
return self._factory.create_set_response(addresses)
class ValidatorRegistryMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding="application/protobuf",
family_name="sawtooth_validator_registry",
family_version="1.0",
namespace="6a4372",
private=private,
public=public)
self.pubkey_hash = hashlib.sha256(public.encode()).hexdigest()
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
# Currently this is done in the enclave
def create_signup_info(self, originator_public_key_hash,
most_recent_wait_certificate_id):
# First we need to create a public/private key pair for the PoET
# enclave to use.
_poet_private_key = \
"1f70fa2518077ad18483f48e77882d11983b537fa5f7cf158684d2c670fe4f1f"
_poet_public_key = \
signing.generate_pubkey(_poet_private_key)
# currently not used
# _active_wait_timer = None
_report_private_key = \
signing.encode_privkey(
signing.decode_privkey(
'5Jz5Kaiy3kCiHE537uXcQnJuiNJshf2bZZn43CrALMGoCd3zRuo',
'wif'), 'hex')
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key': signing.encode_pubkey(_poet_public_key, 'hex'),
'poet_private_key': signing.encode_privkey(_poet_private_key,
'hex')
}
# Create a fake report
report_data = '{0}{1}'.format(
originator_public_key_hash.upper(),
signing.encode_pubkey(_poet_public_key, 'hex').upper())
quote = {
'report_body':
hashlib.sha256(json.dumps(report_data).encode()).hexdigest()
}
# Fake our "proof" data.
verification_report = {
'id':
base64.b64encode(
bytes(
hashlib.sha256(b'2017-02-16T15:21:24.437048').hexdigest().
encode())).decode(),
'isvEnclaveQuoteStatus':
'OK',
'isvEnclaveQuoteBody':
base64.b64encode(json.dumps(quote).encode()).decode(),
'pseManifestStatus':
'OK',
'pseManifestHash':
base64.b64encode(
hashlib.sha256(
bytes(
b'Do you believe in '
b'manifest destiny?')).hexdigest().encode()).decode(),
'nonce':
most_recent_wait_certificate_id
}
proof_data_dict = {
'verification_report':
json.dumps(verification_report),
'signature':
signing.sign(json.dumps(verification_report), _report_private_key)
}
proof_data = json.dumps(proof_data_dict)
return \
SignUpInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
anti_sybil_id=originator_public_key_hash)
def create_tp_process_request(self, validator_id, payload):
inputs = [self._key_to_address('validator_list')]
outputs = [
self._key_to_address('validator_list'),
self._key_to_address(validator_id)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_get_request_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_get_request(addresses)
def create_get_response_validator_info(self, validator_name):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(registered="registered",
name=validator_name,
id=self.public_key,
signup_info=signup_info,
block_num=0).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_get_response({address: data})
def create_set_request_validator_info(self, validator_name, reg):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(registered=reg,
name=validator_name,
id=self.public_key,
signup_info=signup_info,
block_num=0).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_set_request({address: data})
def create_set_response_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_set_response(addresses)
def create_get_request_validator_map(self):
address = self._key_to_address("validator_map")
addresses = [address]
return self._factory.create_get_request(addresses)
def create_get_empty_resposne_validator_map(self):
address = self._key_to_address("validator_map")
data = ValidatorMap().SerializeToString()
return self._factory.create_get_response({address: data})
def create_get_response_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_get_response({address: data})
def create_set_request_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_set_request({address: data})
def create_set_response_validator_map(self):
addresses = [self._key_to_address("validator_map")]
return self._factory.create_set_response(addresses)
class ValidatorRegistryMessageFactory(object):
# The basename and enclave measurement values we will put into the enclave
# quote in the attestation verification report.
__VALID_BASENAME__ = \
bytes.fromhex(
'b785c58b77152cbe7fd55ee3851c4990'
'00000000000000000000000000000000')
__VALID_ENCLAVE_MEASUREMENT__ = \
bytes.fromhex(
'c99f21955e38dbb03d2ca838d3af6e43'
'ef438926ed02db4cc729380c8c7a174e')
__REPORT_PRIVATE_KEY_PEM__ = \
'-----BEGIN PRIVATE KEY-----\n' \
'MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCsy/NmLwZP6Uj0\n' \
'p5mIiefgK8VOK7KJ34g3h0/X6aFOd/Ff4j+e23wtQpkxsjVHWLM5SjElGhfpVDhL\n' \
'1WAMsQI9bpCWR4sjV6p7gOJhv34nkA2Grj5eSHCAJRQXCl+pJ9dYIeKaNoaxkdtq\n' \
'+Xme//ohtkkv/ZjMTfsjMl0RLXokJ+YhSuTpNSovRaCtZfLB5MihVJuV3Qzb2ROh\n' \
'KQxcuyPy9tBtOIrBWJaFiXOLRxAijs+ICyzrqUBbRfoAztkljIBx9KNItHiC4zPv\n' \
'o6DxpGSO2yMQSSrs13PkfyGWVZSgenEYOouEz07X+H5B29PPuW5mCl4nkoH3a9gv\n' \
'rI6VLEx9AgMBAAECggEAImfFge4RCq4/eX85gcc7pRXyBjuLJAqe+7d0fWAmXxJg\n' \
'vB+3XTEEi5p8GDoMg7U0kk6kdGe6pRnAz9CffEduU78FCPcbzCCzcD3cVWwkeUok\n' \
'd1GQV4OC6vD3DBNjsrGdHg45KU18CjUphCZCQhdjvXynG+gZmWxZecuYXkg4zqPT\n' \
'LwOkcdWBPhJ9CbjtiYOtKDZbhcbdfnb2fkxmvnAoz1OWNfVFXh+x7651FrmL2Pga\n' \
'xGz5XoxFYYT6DWW1fL6GNuVrd97wkcYUcjazMgunuUMC+6XFxqK+BoqnxeaxnsSt\n' \
'G2r0sdVaCyK1sU41ftbEQsc5oYeQ3v5frGZL+BgrYQKBgQDgZnjqnVI/B+9iarx1\n' \
'MjAFyhurcKvFvlBtGKUg9Q62V6wI4VZvPnzA2zEaR1J0cZPB1lCcMsFACpuQF2Mr\n' \
'3VDyJbnpSG9q05POBtfLjGQdXKtGb8cfXY2SwjzLH/tvxHm3SP+RxvLICQcLX2/y\n' \
'GTJ+mY9C6Hs6jIVLOnMWkRWamQKBgQDFITE3Qs3Y0ZwkKfGQMKuqJLRw29Tyzw0n\n' \
'XKaVmO/pEzYcXZMPBrFhGvdmNcJLo2fcsmGZnmit8RP4ChwHUlD11dH1Ffqw9FWc\n' \
'387i0chlE5FhQPirSM8sWFVmjt2sxC4qFWJoAD/COQtKHgEaVKVc4sH/yRostL1C\n' \
'r+7aWuqzhQKBgQDcuC5LJr8VPGrbtPz1kY3mw+r/cG2krRNSm6Egj6oO9KFEgtCP\n' \
'zzjKQU9E985EtsqNKI5VdR7cLRLiYf6r0J6j7zO0IAlnXADP768miUqYDuRw/dUw\n' \
'JsbwCZneefDI+Mp325d1/egjla2WJCNqUBp4p/Zf62f6KOmbGzzEf6RuUQKBgG2y\n' \
'E8YRiaTOt5m0MXUwcEZk2Hg5DF31c/dkalqy2UYU57aPJ8djzQ8hR2x8G9ulWaWJ\n' \
'KiCm8s9gaOFNFt3II785NfWxPmh7/qwmKuUzIdWFNxAsbHQ8NvURTqyccaSzIpFO\n' \
'hw0inlhBEBQ1cB2r3r06fgQNb2BTT0Itzrd5gkNVAoGBAJcMgeKdBMukT8dKxb4R\n' \
'1PgQtFlR3COu2+B00pDyUpROFhHYLw/KlUv5TKrH1k3+E0KM+winVUIcZHlmFyuy\n' \
'Ilquaova1YSFXP5cpD+PKtxRV76Qlqt6o+aPywm81licdOAXotT4JyJhrgz9ISnn\n' \
'J13KkHoAZ9qd0rX7s37czb3O\n' \
'-----END PRIVATE KEY-----'
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
family_name="sawtooth_validator_registry",
family_version="1.0",
namespace="6a4372",
private=private,
public=public
)
self.public_key_hash = hashlib.sha256(public.encode()).hexdigest()
self._report_private_key = \
serialization.load_pem_private_key(
self.__REPORT_PRIVATE_KEY_PEM__.encode(),
password=None,
backend=backends.default_backend())
# First we need to create a public/private key pair for the PoET
# enclave to use.
self._poet_private_key = \
"1f70fa2518077ad18483f48e77882d11983b537fa5f7cf158684d2c670fe4f1f"
self.poet_public_key = \
signing.generate_public_key(self._poet_private_key)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
# Utility function for creating proof data as we need to be
# able to update signatures when verification report changes
# Returns a serialized proof data
def create_proof_data(self, verification_report, evidence_payload):
verification_report_json = json.dumps(verification_report)
signature = \
self._report_private_key.sign(
verification_report_json.encode(),
padding.PKCS1v15(),
hashes.SHA256())
proof_data_dict = OrderedDict([
('evidence_payload', evidence_payload),
('verification_report', verification_report_json),
('signature', base64.b64encode(signature).decode())]
)
return json.dumps(proof_data_dict)
# Currently this is done in the enclave
def create_signup_info(self, originator_public_key_hash, nonce,
pse_manifest_status='OK'):
# currently not used
# _active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key': self.poet_public_key,
'poet_private_key': self._poet_private_key
}
# Build up a fake SGX quote containing:
# 1. The basename
# 2. The report body that contains:
# a. The enclave measurement
# b. The report data SHA256(SHA256(OPK)|PPK)
sgx_basename = \
sgx_structs.SgxBasename(name=self.__VALID_BASENAME__)
sgx_measurement = \
sgx_structs.SgxMeasurement(
m=self.__VALID_ENCLAVE_MEASUREMENT__)
hash_input = \
'{0}{1}'.format(
originator_public_key_hash.upper(),
self.poet_public_key.upper()).encode()
report_data = hashlib.sha256(hash_input).digest()
sgx_report_data = sgx_structs.SgxReportData(d=report_data)
sgx_report_body = \
sgx_structs.SgxReportBody(
mr_enclave=sgx_measurement,
report_data=sgx_report_data)
sgx_quote = \
sgx_structs.SgxQuote(
basename=sgx_basename,
report_body=sgx_report_body)
# Create a fake PSE manifest. A base64 encoding of the
# originator public key hash should suffice.
pse_manifest = \
base64.b64encode(originator_public_key_hash.encode())
timestamp = '2017-02-16T15:21:24.437048'
# Fake our "proof" data.
verification_report = OrderedDict([
('epidPseudonym', originator_public_key_hash),
('id', base64.b64encode(
hashlib.sha256(
timestamp.encode()).hexdigest().encode()).decode()),
('isvEnclaveQuoteStatus', 'OK'),
('isvEnclaveQuoteBody',
base64.b64encode(sgx_quote.serialize_to_bytes()).decode()),
('pseManifestStatus', pse_manifest_status),
('pseManifestHash',
hashlib.sha256(base64.b64decode(pse_manifest)).hexdigest()),
('nonce', nonce),
('timestamp', timestamp)
])
proof_data = \
self.create_proof_data(
verification_report=verification_report,
evidence_payload={
'pse_manifest': pse_manifest.decode()
})
return \
SignUpInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
anti_sybil_id=originator_public_key_hash,
nonce=nonce)
def create_tp_process_request(self, validator_id, payload):
inputs = [
self._key_to_address('validator_list')
]
outputs = [
self._key_to_address('validator_list'),
self._key_to_address(validator_id)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [], False)
def create_get_request_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_get_request(addresses)
def create_set_request_validator_info(
self, validator_name, transaction_id, signup_info=None):
if signup_info is None:
signup_info = self.create_signup_info(self.public_key_hash, "000")
data = ValidatorInfo(
name=validator_name,
id=self.public_key,
signup_info=signup_info,
transaction_id=transaction_id
).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_set_request({address: data})
def create_set_response_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_set_response(addresses)
def create_del_request_validator_info(self):
data = b''
address = self._key_to_address(self.public_key)
return self._factory.create_set_request({address: data})
def create_del_response_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_set_response(addresses)
def create_get_request_validator_map(self):
address = self._key_to_address("validator_map")
addresses = [address]
return self._factory.create_get_request(addresses)
def create_get_empty_response_validator_map(self):
address = self._key_to_address("validator_map")
data = ValidatorMap().SerializeToString()
return self._factory.create_get_response({address: data})
def create_get_response_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.public_key_hash,
value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_get_response({address: data})
def create_set_request_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.public_key_hash,
value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_set_request({address: data})
def create_set_response_validator_map(self):
addresses = [self._key_to_address("validator_map")]
return self._factory.create_set_response(addresses)
def create_get_request_report_key_pem(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8e97a7d614626e4500e3b0c44298fc1c14'])
def create_get_response_report_key_pem(self, pem=None):
setting = Setting()
if pem is not None:
entry = Setting.Entry(key='sawtooth.poet.report_public_key_pem',
value=pem)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8e97a7d614626e4500e3b0c44298fc1c14': data})
def create_get_response_simulator_report_key_pem(self):
pem = '''-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArMvzZi8GT+lI9KeZiInn
4CvFTiuyid+IN4dP1+mhTnfxX+I/ntt8LUKZMbI1R1izOUoxJRoX6VQ4S9VgDLEC
PW6QlkeLI1eqe4DiYb9+J5ANhq4+XkhwgCUUFwpfqSfXWCHimjaGsZHbavl5nv/6
IbZJL/2YzE37IzJdES16JCfmIUrk6TUqL0WgrWXyweTIoVSbld0M29kToSkMXLsj
8vbQbTiKwViWhYlzi0cQIo7PiAss66lAW0X6AM7ZJYyAcfSjSLR4guMz76Og8aRk
jtsjEEkq7Ndz5H8hllWUoHpxGDqLhM9O1/h+QdvTz7luZgpeJ5KB92vYL6yOlSxM
fQIDAQAB
-----END PUBLIC KEY-----'''
return self.create_get_response_report_key_pem(pem=pem)
def create_get_request_enclave_measurements(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8e39ccaeec28506829e3b0c44298fc1c14'])
def create_get_response_enclave_measurements(self, measurements=None):
setting = Setting()
if measurements is not None:
entry = Setting.Entry(key='sawtooth.poet.'
'valid_enclave_measurements',
value=measurements)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8e39ccaeec28506829e3b0c44298fc1c14': data})
def create_get_response_simulator_enclave_measurements(self):
return \
self.create_get_response_enclave_measurements(
measurements='c99f21955e38dbb03d2ca838d3af6e43'
'ef438926ed02db4cc729380c8c7a174e')
def create_get_request_enclave_basenames(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8ebec3b47bc008b27de3b0c44298fc1c14'])
def create_get_response_enclave_basenames(self, basenames=None):
setting = Setting()
if basenames is not None:
entry = Setting.Entry(key='sawtooth.poet.'
'valid_enclave_basenames',
value=basenames)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8ebec3b47bc008b27de3b0c44298fc1c14': data})
def create_get_response_simulator_enclave_basenames(self):
return \
self.create_get_response_enclave_basenames(
basenames='b785c58b77152cbe7fd55ee3851c4990'
'00000000000000000000000000000000')
class ValidatorRegistryMessageFactory(object):
# The basename and enclave measurement values we will put into the enclave
# quote in the attestation verification report.
__VALID_BASENAME__ = \
bytes.fromhex(
'b785c58b77152cbe7fd55ee3851c4990'
'00000000000000000000000000000000')
__VALID_ENCLAVE_MEASUREMENT__ = \
bytes.fromhex(
'c99f21955e38dbb03d2ca838d3af6e43'
'ef438926ed02db4cc729380c8c7a174e')
__REPORT_PRIVATE_KEY_PEM__ = \
'-----BEGIN PRIVATE KEY-----\n' \
'MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCsy/NmLwZP6Uj0\n' \
'p5mIiefgK8VOK7KJ34g3h0/X6aFOd/Ff4j+e23wtQpkxsjVHWLM5SjElGhfpVDhL\n' \
'1WAMsQI9bpCWR4sjV6p7gOJhv34nkA2Grj5eSHCAJRQXCl+pJ9dYIeKaNoaxkdtq\n' \
'+Xme//ohtkkv/ZjMTfsjMl0RLXokJ+YhSuTpNSovRaCtZfLB5MihVJuV3Qzb2ROh\n' \
'KQxcuyPy9tBtOIrBWJaFiXOLRxAijs+ICyzrqUBbRfoAztkljIBx9KNItHiC4zPv\n' \
'o6DxpGSO2yMQSSrs13PkfyGWVZSgenEYOouEz07X+H5B29PPuW5mCl4nkoH3a9gv\n' \
'rI6VLEx9AgMBAAECggEAImfFge4RCq4/eX85gcc7pRXyBjuLJAqe+7d0fWAmXxJg\n' \
'vB+3XTEEi5p8GDoMg7U0kk6kdGe6pRnAz9CffEduU78FCPcbzCCzcD3cVWwkeUok\n' \
'd1GQV4OC6vD3DBNjsrGdHg45KU18CjUphCZCQhdjvXynG+gZmWxZecuYXkg4zqPT\n' \
'LwOkcdWBPhJ9CbjtiYOtKDZbhcbdfnb2fkxmvnAoz1OWNfVFXh+x7651FrmL2Pga\n' \
'xGz5XoxFYYT6DWW1fL6GNuVrd97wkcYUcjazMgunuUMC+6XFxqK+BoqnxeaxnsSt\n' \
'G2r0sdVaCyK1sU41ftbEQsc5oYeQ3v5frGZL+BgrYQKBgQDgZnjqnVI/B+9iarx1\n' \
'MjAFyhurcKvFvlBtGKUg9Q62V6wI4VZvPnzA2zEaR1J0cZPB1lCcMsFACpuQF2Mr\n' \
'3VDyJbnpSG9q05POBtfLjGQdXKtGb8cfXY2SwjzLH/tvxHm3SP+RxvLICQcLX2/y\n' \
'GTJ+mY9C6Hs6jIVLOnMWkRWamQKBgQDFITE3Qs3Y0ZwkKfGQMKuqJLRw29Tyzw0n\n' \
'XKaVmO/pEzYcXZMPBrFhGvdmNcJLo2fcsmGZnmit8RP4ChwHUlD11dH1Ffqw9FWc\n' \
'387i0chlE5FhQPirSM8sWFVmjt2sxC4qFWJoAD/COQtKHgEaVKVc4sH/yRostL1C\n' \
'r+7aWuqzhQKBgQDcuC5LJr8VPGrbtPz1kY3mw+r/cG2krRNSm6Egj6oO9KFEgtCP\n' \
'zzjKQU9E985EtsqNKI5VdR7cLRLiYf6r0J6j7zO0IAlnXADP768miUqYDuRw/dUw\n' \
'JsbwCZneefDI+Mp325d1/egjla2WJCNqUBp4p/Zf62f6KOmbGzzEf6RuUQKBgG2y\n' \
'E8YRiaTOt5m0MXUwcEZk2Hg5DF31c/dkalqy2UYU57aPJ8djzQ8hR2x8G9ulWaWJ\n' \
'KiCm8s9gaOFNFt3II785NfWxPmh7/qwmKuUzIdWFNxAsbHQ8NvURTqyccaSzIpFO\n' \
'hw0inlhBEBQ1cB2r3r06fgQNb2BTT0Itzrd5gkNVAoGBAJcMgeKdBMukT8dKxb4R\n' \
'1PgQtFlR3COu2+B00pDyUpROFhHYLw/KlUv5TKrH1k3+E0KM+winVUIcZHlmFyuy\n' \
'Ilquaova1YSFXP5cpD+PKtxRV76Qlqt6o+aPywm81licdOAXotT4JyJhrgz9ISnn\n' \
'J13KkHoAZ9qd0rX7s37czb3O\n' \
'-----END PRIVATE KEY-----'
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding="application/protobuf",
family_name="sawtooth_validator_registry",
family_version="1.0",
namespace="6a4372",
private=private,
public=public
)
self.pubkey_hash = hashlib.sha256(public.encode()).hexdigest()
self._report_private_key = \
serialization.load_pem_private_key(
self.__REPORT_PRIVATE_KEY_PEM__.encode(),
password=None,
backend=backends.default_backend())
# First we need to create a public/private key pair for the PoET
# enclave to use.
self._poet_private_key = \
"1f70fa2518077ad18483f48e77882d11983b537fa5f7cf158684d2c670fe4f1f"
self.poet_public_key = \
signing.generate_pubkey(self._poet_private_key)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
# Utility function for creating proof data as we need to be
# able to update signatures when verification report changes
# Returns a serialized proof data
def create_proof_data(self, verification_report, evidence_payload):
verification_report_json = json.dumps(verification_report)
signature = \
self._report_private_key.sign(
verification_report_json.encode(),
padding.PKCS1v15(),
hashes.SHA256())
proof_data_dict = OrderedDict([
('evidence_payload', evidence_payload),
('verification_report', verification_report_json),
('signature', base64.b64encode(signature).decode())]
)
return json.dumps(proof_data_dict)
# Currently this is done in the enclave
def create_signup_info(self, originator_public_key_hash, nonce):
# currently not used
# _active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key': self.poet_public_key,
'poet_private_key': self._poet_private_key
}
# Build up a fake SGX quote containing:
# 1. The basename
# 2. The report body that contains:
# a. The enclave measurement
# b. The report data SHA256(SHA256(OPK)|PPK)
sgx_basename = \
sgx_structs.SgxBasename(name=self.__VALID_BASENAME__)
sgx_measurement = \
sgx_structs.SgxMeasurement(
m=self.__VALID_ENCLAVE_MEASUREMENT__)
hash_input = \
'{0}{1}'.format(
originator_public_key_hash.upper(),
self.poet_public_key.upper()).encode()
report_data = hashlib.sha256(hash_input).digest()
sgx_report_data = sgx_structs.SgxReportData(d=report_data)
sgx_report_body = \
sgx_structs.SgxReportBody(
mr_enclave=sgx_measurement,
report_data=sgx_report_data)
sgx_quote = \
sgx_structs.SgxQuote(
basename=sgx_basename,
report_body=sgx_report_body)
# Create a fake PSE manifest. A base64 encoding of the
# originator public key hash should suffice.
pse_manifest = \
base64.b64encode(originator_public_key_hash.encode())
timestamp = '2017-02-16T15:21:24.437048'
# Fake our "proof" data.
verification_report = OrderedDict([
('epidPseudonym', originator_public_key_hash),
('id', base64.b64encode(
hashlib.sha256(
timestamp.encode()).hexdigest().encode()).decode()),
('isvEnclaveQuoteStatus', 'OK'),
('isvEnclaveQuoteBody',
base64.b64encode(sgx_quote.serialize_to_bytes()).decode()),
('pseManifestStatus', 'OK'),
('pseManifestHash',
hashlib.sha256(base64.b64decode(pse_manifest)).hexdigest()),
('nonce', nonce),
('timestamp', timestamp)
])
proof_data = \
self.create_proof_data(
verification_report=verification_report,
evidence_payload={
'pse_manifest': pse_manifest.decode()
})
return \
SignUpInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
anti_sybil_id=originator_public_key_hash,
nonce=nonce)
def create_tp_process_request(self, validator_id, payload):
inputs = [
self._key_to_address('validator_list')
]
outputs = [
self._key_to_address('validator_list'),
self._key_to_address(validator_id)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [], False)
def create_get_request_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_get_request(addresses)
def create_get_response_validator_info(self, validator_name):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(
registered="registered",
name=validator_name,
id=self.public_key,
signup_info=signup_info,
transaction_id="0103c991863cae73630fe0a9b8988ad35840a3994ad010cd4c"
"60f17ca70b2054115bd5bdb0233f745826a61db0d83a32365f"
"e4026b39a731b0e457a5f09be194"
).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_get_response({address: data})
def create_set_request_validator_info(self, validator_name, reg):
signup_info = self.create_signup_info(self.pubkey_hash, "000")
data = ValidatorInfo(
registered=reg,
name=validator_name,
id=self.public_key,
signup_info=signup_info,
transaction_id="0103c991863cae73630fe0a9b8988ad35840a3994ad010cd4c"
"60f17ca70b2054115bd5bdb0233f745826a61db0d83a32365f"
"e4026b39a731b0e457a5f09be194"
).SerializeToString()
address = self._key_to_address(self.public_key)
return self._factory.create_set_request({address: data})
def create_set_response_validator_info(self):
addresses = [self._key_to_address(self.public_key)]
return self._factory.create_set_response(addresses)
def create_get_request_validator_map(self):
address = self._key_to_address("validator_map")
addresses = [address]
return self._factory.create_get_request(addresses)
def create_get_empty_response_validator_map(self):
address = self._key_to_address("validator_map")
data = ValidatorMap().SerializeToString()
return self._factory.create_get_response({address: data})
def create_get_response_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_get_response({address: data})
def create_set_request_validator_map(self):
address = self._key_to_address("validator_map")
validator_map = ValidatorMap()
validator_map.entries.add(key=self.pubkey_hash, value=self.public_key)
data = validator_map.SerializeToString()
return self._factory.create_set_request({address: data})
def create_set_response_validator_map(self):
addresses = [self._key_to_address("validator_map")]
return self._factory.create_set_response(addresses)
def create_get_request_report_key_pem(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8e97a7d614626e4500e3b0c44298fc1c14'])
def create_get_response_report_key_pem(self, pem=None):
setting = Setting()
if pem is not None:
entry = Setting.Entry(key='sawtooth.poet.report_public_key_pem',
value=pem)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8e97a7d614626e4500e3b0c44298fc1c14': data})
def create_get_response_simulator_report_key_pem(self):
pem = '''-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArMvzZi8GT+lI9KeZiInn
4CvFTiuyid+IN4dP1+mhTnfxX+I/ntt8LUKZMbI1R1izOUoxJRoX6VQ4S9VgDLEC
PW6QlkeLI1eqe4DiYb9+J5ANhq4+XkhwgCUUFwpfqSfXWCHimjaGsZHbavl5nv/6
IbZJL/2YzE37IzJdES16JCfmIUrk6TUqL0WgrWXyweTIoVSbld0M29kToSkMXLsj
8vbQbTiKwViWhYlzi0cQIo7PiAss66lAW0X6AM7ZJYyAcfSjSLR4guMz76Og8aRk
jtsjEEkq7Ndz5H8hllWUoHpxGDqLhM9O1/h+QdvTz7luZgpeJ5KB92vYL6yOlSxM
fQIDAQAB
-----END PUBLIC KEY-----'''
return self.create_get_response_report_key_pem(pem=pem)
def create_get_request_enclave_measurements(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8e39ccaeec28506829e3b0c44298fc1c14'])
def create_get_response_enclave_measurements(self, measurements=None):
setting = Setting()
if measurements is not None:
entry = Setting.Entry(key='sawtooth.poet.'
'valid_enclave_measurements',
value=measurements)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8e39ccaeec28506829e3b0c44298fc1c14': data})
def create_get_response_simulator_enclave_measurements(self):
return \
self.create_get_response_enclave_measurements(
measurements='c99f21955e38dbb03d2ca838d3af6e43'
'ef438926ed02db4cc729380c8c7a174e')
def create_get_request_enclave_basenames(self):
return \
self._factory.create_get_request(
['000000a87cb5eafdcca6a87ccc804f5546a'
'b8ebec3b47bc008b27de3b0c44298fc1c14'])
def create_get_response_enclave_basenames(self, basenames=None):
setting = Setting()
if basenames is not None:
entry = Setting.Entry(key='sawtooth.poet.'
'valid_enclave_basenames',
value=basenames)
setting.entries.extend([entry])
data = setting.SerializeToString()
return self._factory.create_get_response(
{'000000a87cb5eafdcca6a87ccc804f5546a'
'b8ebec3b47bc008b27de3b0c44298fc1c14': data})
def create_get_response_simulator_enclave_basenames(self):
return \
self.create_get_response_enclave_basenames(
basenames='b785c58b77152cbe7fd55ee3851c4990'
'00000000000000000000000000000000')
class UnitMessageFactory(object):
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="hashblock_units",
family_version="0.1.0",
namespace=[MessageFactory.sha512('units'.encode("utf-8"))[0:6]],
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
key_parts = key.split('.', maxsplit=_MAX_KEY_PARTS - 1)
key_parts.extend([''] * (_MAX_KEY_PARTS - len(key_parts)))
def _short_hash(in_str):
return self._factory.sha256(in_str.encode())[:16]
return self._factory.namespace + \
''.join(_short_hash(x) for x in key_parts)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, code, payload):
inputs = [
self._key_to_address('hashblock.units.vote.proposals'),
self._key_to_address('hashblock.units.vote.authorized_keys'),
self._key_to_address('hashblock.units.vote.approval_threshold'),
self._key_to_address(code)
]
outputs = [
self._key_to_address('hashblock.units.vote.proposals'),
self._key_to_address(code)
]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, code, value, nonce):
proposal = UnitProposal(code=code, value=value, nonce=nonce)
payload = UnitPayload(action=UnitPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_tp_process_request(code, payload)
def create_vote_proposal(self, proposal_id, code, vote):
vote = UnitVote(proposal_id=proposal_id, vote=vote)
payload = UnitPayload(action=UnitPayload.VOTE,
data=vote.SerializeToString())
return self._create_tp_process_request(code, payload)
def create_get_request(self, code):
addresses = [self._key_to_address(code)]
return self._factory.create_get_request(addresses)
def create_get_response(self, code, value=None):
address = self._key_to_address(code)
if value is not None:
entry = Unit.Entry(key=code, value=value)
data = Unit(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, code, value=None):
address = self._key_to_address(code)
if value is not None:
entry = Unit.Entry(key=code, value=value)
data = Unit(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, code):
addresses = [self._key_to_address(code)]
return self._factory.create_set_response(addresses)
def create_add_event_request(self, key):
return self._factory.create_add_event_request("units/update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class IntkeyMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="application/cbor",
family_name="intkey",
family_version="1.0",
namespace="",
private=private,
public=public)
self._factory.namespace = self._factory.sha512(
"intkey".encode("utf-8"))[0:6]
def _dumps(self, obj):
return cbor.dumps(obj, sort_keys=True)
def _loads(self, data):
return cbor.loads(data)
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha512(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def create_transaction(self, verb, name, value):
payload = self._dumps({"Verb": verb, "Name": name, "Value": value})
addresses = [self._key_to_address(name)]
return self._factory.create_transaction(payload, addresses, addresses,
[])
def create_get_request(self, name):
addresses = [self._key_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name, value):
address = self._key_to_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, name, value):
address = self._key_to_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name):
addresses = [self._key_to_address(name)]
return self._factory.create_set_response(addresses)
class SoceMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="soce",
family_version="1.0",
namespace=MessageFactory.sha512("soce".encode("utf-8"))[0:6],
signer=signer)
def voting_voter_to_address(self, name_id):
return self._factory.namespace + \
self._factory.sha512(name_id.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, action = None, name_id = None, configurations_preferences_id = None, sc_method = None):
payload = ";".join([
str(action), str(name_id), str(configurations_preferences_id), str(sc_method)
]).encode()
print('txn en camino!', payload)
addresses = [self.voting_voter_to_address(name_id), self.voting_voter_to_address(configurations_preferences_id)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action = None, name_id = None, configurations_preferences_id = None, sc_method = None):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, action, name_id, configurations_preferences_id, sc_method)
def create_transaction(self, action = None, name_id = None, configurations_preferences_id = None, sc_method = None):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, action, name_id, configurations_preferences_id, sc_method)
def create_get_request(self, name_id):
addresses = [self.voting_voter_to_address(name_id)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name_id, value = None):
address = self.voting_voter_to_address(name_id)
data = None
if value is not None:
data = ";".join([name_id, value]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, action = None, name_id = None, configurations_preferences = None, sc_method = None):
address = self.voting_voter_to_address(name_id)
print('create_set_request')
data = None
if value is not None:
data = ";".join([str(action), str(name_id), str(configurations_preferences), str(sc_method)]).encode()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name_id):
addresses = [self.voting_voter_to_address(name_id)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class MatchMessageFactory(object):
def __init__(self, signer=None):
self._match_addr = Address(Address.FAMILY_MATCH)
self._factory = MessageFactory(
family_name=Address.NAMESPACE_MATCH,
family_version="0.1.0",
namespace=[self._match_addr.ns_family],
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, payload, ukey, mkey=None):
if mkey:
inputs = [ukey]
outputs = [ukey, mkey]
else:
inputs = []
outputs = [ukey]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_initiate_transaction(self, initiate_event, ukey, command):
payload = MatchEvent(
action=command,
ukey=ukey,
data=initiate_event.SerializeToString())
return self._create_tp_process_request(payload, ukey)
def create_reciprocate_transaction(
self,
reciprocate_event,
ukey,
mkey,
command):
payload = MatchEvent(
action=command,
ukey=ukey,
mkey=mkey,
data=reciprocate_event.SerializeToString())
return self._create_tp_process_request(payload, ukey, mkey)
def create_get_request(self, address):
return self._factory.create_get_request([address])
def create_get_response(self, address, data=None):
return self._factory.create_get_response({address: data})
def create_set_request(self, address, data=None):
return self._factory.create_set_request({address: data})
def create_set_response(self, address):
return self._factory.create_set_response([address])
def create_add_event_request(self, key, attributes):
return self._factory.create_add_event_request(
key,
attributes)
def create_add_event_response(self):
return self._factory.create_add_event_response()
class IntkeyMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name='registry',
family_version='0.1',
namespace=INTKEY_ADDRESS_PREFIX,
signer=signer)
def _dumps(self, obj):
return cbor.dumps(obj, sort_keys=True)
def _loads(self, data):
return cbor.loads(data)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, name, author, docHash, url):
payload = self._dumps({'Name': name, 'Author': author, 'DocHash': docHash, 'Url': url})
addresses = [make_registry_address(name)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, name, author, docHash, url,):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, name, author, docHash, url)
def create_transaction(self, name, author, docHash, url,):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, name, author, docHash, url)
def create_batch(self, triples):
txns = [
self.create_transaction(name, author, docHash, url)
for name, author, docHash, url in triples
]
return self._factory.create_batch(txns)
def create_get_request(self, name):
addresses = [make_regestry_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name, author, docHash, url):
address = make_registry_address(name)
if value is not None:
data = self._dumps({name: name, author, docHash, url})
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, name, author, docHash, url):
address = make_intkey_address(name)
if value is not None:
data = self._dumps({name: name, author, docHash, url})
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name):
addresses = [make_intkey_address(name)]
return self._factory.create_set_response(addresses)
class IntkeyMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name='intkey',
family_version='1.0',
namespace=INTKEY_ADDRESS_PREFIX,
signer=signer)
def _dumps(self, obj):
return cbor.dumps(obj, sort_keys=True)
def _loads(self, data):
return cbor.loads(data)
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, verb, name, value):
payload = self._dumps({'Verb': verb, 'Name': name, 'Value': value})
addresses = [make_intkey_address(name)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, verb, name, value,):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, verb, name, value)
def create_transaction(self, verb, name, value,):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, verb, name, value)
def create_batch(self, triples):
txns = [
self.create_transaction(verb, name, value)
for verb, name, value in triples
]
return self._factory.create_batch(txns)
def create_get_request(self, name):
addresses = [make_intkey_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name, value):
address = make_intkey_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, name, value):
address = make_intkey_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name):
addresses = [make_intkey_address(name)]
return self._factory.create_set_response(addresses)
class XoMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="csv-utf8",
family_name="xo",
family_version="1.0",
namespace=MessageFactory.sha512(
"xo".encode("utf-8"))[0:6],
private=private,
public=public)
def _game_to_address(self, game):
return self._factory.namespace + \
self._factory.sha512(game.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, game, action, space=None):
payload = ",".join([str(game), str(action), str(space)]).encode()
addresses = [self._game_to_address(game)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, game, space=None):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, game, action, space)
def create_transaction(self, game, action, space=None):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, game, action, space)
def create_get_request(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_get_request(addresses)
def create_get_response(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._game_to_address(game)
data = None
if board is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._game_to_address(game)
data = None
if state is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_response(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class AssetMessageFactory(object):
def __init__(self, signer=None):
self._asset_addr = Address(Address.FAMILY_ASSET)
self._setting_addr = Address(Address.FAMILY_SETTING)
self._factory = MessageFactory(family_name=Address.NAMESPACE_ASSET,
family_version="0.1.0",
namespace=[self._asset_addr.ns_family],
signer=signer)
@property
def public_key(self):
return self._factory.get_public_key()
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, asset, dimension, payload):
asset_address = self._asset_addr.asset_item(dimension, asset.system,
asset.key)
inputs = [
self._setting_addr.settings(dimension),
self._asset_addr.candidates(dimension), asset_address
]
outputs = [self._asset_addr.candidates(dimension), asset_address]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_proposal_transaction(self, asset, dimension, nonce):
proposal = AssetProposal(
asset=asset.SerializeToString(),
type=AssetProposal.UNIT
if dimension is Address.DIMENSION_UNIT else AssetProposal.RESOURCE,
nonce=nonce)
payload = AssetPayload(action=AssetPayload.ACTION_PROPOSE,
dimension=dimension,
data=proposal.SerializeToString())
return self._create_tp_process_request(asset, dimension, payload)
def create_vote_transaction(self, proposal_id, asset, dimension, vote):
avote = AssetVote(proposal_id=proposal_id, vote=vote)
payload = AssetPayload(action=AssetPayload.ACTION_VOTE,
dimension=dimension,
data=avote.SerializeToString())
return self._create_tp_process_request(asset, dimension, payload)
def create_unset_vote_transaction(self, proposal_id, asset, dimension,
vote):
avote = AssetVote(proposal_id=proposal_id, vote=vote)
payload = AssetPayload(action=AssetPayload.ACTION_UNSET,
dimension=dimension,
data=avote.SerializeToString())
return self._create_tp_process_request(asset, dimension, payload)
def create_get_request(self, address):
addresses = [address]
return self._factory.create_get_request(addresses)
def create_get_response(self, address, data):
return self._factory.create_get_response({address: data})
def create_set_request(self, address, data):
return self._factory.create_set_request({address: data})
def create_set_response(self, address):
addresses = [address]
return self._factory.create_set_response(addresses)
def create_add_event_request(self, address):
return self._factory.create_add_event_request("hashbloc.asset/update",
[("updated", address)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class CertMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(family_name="cert",
family_version="1.0",
namespace=MessageFactory.sha512(
"cert".encode("utf-8"))[0:6],
signer=signer)
def _certificate_to_address(self, certificate):
return self._factory.namespace + \
self._factory.sha512(certificate.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, certificate, action, space=None):
payload = ",".join([str(certificate),
str(action),
str(space)]).encode()
addresses = [self._certificate_to_address(certificate)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, certificate, space=None):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, certificate, action, space)
def create_transaction(self, certificate, action, space=None):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, certificate, action, space)
def create_get_request(self, game):
addresses = [self._certificate_to_address(game)]
return self._factory.create_get_request(addresses)
# Todo: change
def create_get_response(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._certificate_to_address(game)
data = None
if board is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._certificate_to_address(game)
if state is not None:
data = ",".join([game, board, state, player1, player2]).encode()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, certificate):
addresses = [self._certificate_to_address(certificate)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class DQMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(family_name="dq",
family_version="1.0",
namespace=MessageFactory.sha512(
"dq".encode("utf-8"))[0:6],
signer=signer)
def _quality_to_address(self, quality):
return self._factory.namespace + \
self._factory.sha512(quality.encode())[0:64]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_txn(self, txn_function, quality, action):
payload = ",".join([str(quality), str(action)]).encode()
addresses = [self._quality_to_address(quality)]
return txn_function(payload, addresses, addresses, [])
def create_tp_process_request(self, action, quality):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, quality, action)
def create_transaction(self, quality, action):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, quality, action)
def create_get_request(self, quality):
addresses = [self._quality_to_address(quality)]
return self._factory.create_get_request(addresses)
# def create_get_response(
# self, game, board="---------", state="P1-NEXT", player1="", player2=""
# ):
# address = self._game_to_address(game)
#
# data = None
# if board is not None:
# data = ",".join([game, board, state, player1, player2]).encode()
# else:
# data = None
#
# return self._factory.create_get_response({address: data})
#
# def create_set_request(
# self, game, board="---------", state="P1-NEXT", player1="", player2=""
# ):
# address = self._game_to_address(game)
#
# data = None
# if state is not None:
# data = ",".join([game, board, state, player1, player2]).encode()
# else:
# data = None
#
# return self._factory.create_set_request({address: data})
def create_set_response(self, quality):
addresses = [self._quality_to_address(quality)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class IdentityMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(
encoding="application/protobuf",
family_name="sawtooth_identity",
family_version="1.0",
namespace="00001d",
private=private,
public=public
)
@property
def public_key(self):
return self._factory.get_public_key()
def _to_hash(self, value):
return hashlib.sha256(value.encode()).hexdigest()
def _role_to_address(self, role_name):
# split the key into 4 parts, maximum
key_parts = role_name.split('.', maxsplit=_MAX_KEY_PARTS - 1)
# compute the short hash of each part
addr_parts = [self._to_hash(key_parts[0])[:_FIRST_ADDRESS_PART_SIZE]]
addr_parts += [self._to_hash(x)[:_ADDRESS_PART_SIZE] for x in
key_parts[1:]]
# pad the parts with the empty hash, if needed
addr_parts.extend([_EMPTY_PART] * (_MAX_KEY_PARTS - len(addr_parts)))
return self._factory.namespace + _ROLE_PREFIX + ''.join(addr_parts)
def _policy_to_address(self, policy_name):
return self._factory.namespace + _POLICY_PREFIX + \
self._to_hash(policy_name)[:62]
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_tp_process_request(self, payload):
inputs = []
outputs = []
if payload.type == IdentityPayload.ROLE:
role = Role()
role.ParseFromString(payload.data)
inputs = [self._role_to_address(role.name),
self._policy_to_address(role.policy_name)]
outputs = [self._role_to_address(role.name)]
else:
policy = Policy()
policy.ParseFromString(payload.data)
inputs = [self._policy_to_address(policy.name)]
outputs = [self._role_to_address(policy.name)]
return self._factory.create_tp_process_request(
payload.SerializeToString(), inputs, outputs, [])
def create_policy_transaction(self, name, rules):
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[1])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[1])
entries.append(entry)
policy = Policy(name=name, entries=entries)
payload = IdentityPayload(type=IdentityPayload.POLICY,
data=policy.SerializeToString())
return self._create_tp_process_request(payload)
def create_role_transaction(self, name, policy_name):
role = Role(name=name, policy_name=policy_name)
payload = IdentityPayload(type=IdentityPayload.ROLE,
data=role.SerializeToString())
return self._create_tp_process_request(payload)
def create_get_policy_request(self, name):
addresses = [self._policy_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_policy_response(self, name, rules=None):
data = None
if rules is not None:
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[0])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[0])
entries.append(entry)
policy = Policy(name=name, entries=entries)
policy_list = PolicyList(policies=[policy])
data = policy_list.SerializeToString()
return self._factory.create_get_response(
{self._policy_to_address(name): data})
def create_get_role_request(self, name):
addresses = [self._role_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_role_response(self, name, policy_name=None):
data = None
if policy_name is not None:
role = Role(name=name, policy_name=policy_name)
role_list = RoleList(roles=[role])
data = role_list.SerializeToString()
return self._factory.create_get_response({
self._role_to_address(name): data})
def create_set_policy_request(self, name, rules=None):
rules_list = rules.split("\n")
entries = []
for rule in rules_list:
rule = rule.split(" ")
if rule[0] == "PERMIT_KEY":
entry = Policy.Entry(type=Policy.PERMIT_KEY,
key=rule[1])
entries.append(entry)
elif rule[0] == "DENY_KEY":
entry = Policy.Entry(type=Policy.DENY_KEY,
key=rule[1])
entries.append(entry)
policy = Policy(name=name, entries=entries)
policy_list = PolicyList(policies=[policy])
return self._factory.create_set_request({
self._policy_to_address(name): policy_list.SerializeToString()})
def create_set_policy_response(self, name):
addresses = [self._policy_to_address(name)]
return self._factory.create_set_response(addresses)
def create_set_role_request(self, name, policy_name):
role = Role(name=name, policy_name=policy_name)
role_list = RoleList(roles=[role])
return self._factory.create_set_request({
self._role_to_address(name): role_list.SerializeToString()})
def create_set_role_response(self, name):
addresses = [self._role_to_address(name)]
return self._factory.create_set_response(addresses)
def create_get_setting_request(self, key):
addresses = [key]
return self._factory.create_get_request(addresses)
def create_get_setting_response(self, key, allowed):
if allowed:
entry = Setting.Entry(
key="sawtooth.identity.allowed_keys",
value=self.public_key)
data = Setting(entries=[entry]).SerializeToString()
else:
entry = Setting.Entry(
key="sawtooth.identity.allowed_keys",
value="")
data = Setting(entries=[entry]).SerializeToString()
return self._factory.create_get_response({key: data})
def create_add_event_request(self, key):
return self._factory.create_add_event_request(
"identity_update",
[("updated", key)])
def create_add_event_response(self):
return self._factory.create_add_event_response()
class IdentityMessageFactory:
# done
def __init__(self, signer=None):
self._factory = MessageFactory(
family_name="identity",
family_version="0.1",
namespace=MessageFactory.sha512("identity".encode("utf-8"))[0:6],
signer=signer)
# done
def get_public_key(self):
return self._factory.get_public_key()
# done
def _name_to_address(self, name):
return self._factory.namespace + \
self._factory.sha512(name.encode())[0:6] + \
self._factory.sha512(name.encode())[-58:]
# done
def create_tp_register(self):
return self._factory.create_tp_register()
# done
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
# done
def _dumps(self, obj):
return pickle.dumps(obj, protocol=pickle.HIGHEST_PROTOCOL)
# done
def _loads(self, data):
return pickle.loads(data)
# done
def _create_txn(self, txn_function, action, name, date_of_birth='', gender=''):
payload = {
'Action': action
'Name': name,
'Date_of_birth': date_of_birth,
'Gender': gender
}
payload_bytes = self._dumps(payload)
addresses = [self._name_to_address(name)]
return txn_function(payload_bytes, addresses, addresses, [])
# done
def create_tp_process_request(self, action, name, date_of_birth='', gender=''):
txn_function = self._factory.create_tp_process_request
return self._create_txn(txn_function, action, name, date_of_birth, gender)
# done
def create_transaction(self, action, name, date_of_birth='', gender=''):
txn_function = self._factory.create_transaction
return self._create_txn(txn_function, action, name, date_of_birth, gender)
# done
def create_get_request(self, name):
addresses = [self._name_to_address(name)]
return self._factory.create_get_request(addresses)
# done
# Not really sure about this
def create_get_response(self, name, date_of_birth, gender):
address = self._name_to_address(name)
data = None
if date_of_birth is not None and gender is not None:
data = self._dumps({"Name": name, "Date_of_birth": date_of_birth, "Gender": gender})
else:
data = None
return self._factory.create_get_response({address: data})
# done
def create_set_response(self, name):
addresses = [self._name_to_address(name)]
return self._factory.create_set_response(addresses)
# done
# Not really sure about this
def create_set_request(self, name, date_of_birth, gender):
address = self._name_to_address(name)
if date_of_birth is not None and gender is not None:
data = self._dumps({"Name": name, "Date_of_birth": date_of_birth, "Gender": gender})
else:
data = None
return self._factory.create_set_request({address: data})
