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 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 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 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 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 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 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 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 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()