class Client(object): def __init__(self, rest_endpoint): context = create_context('secp256k1') private_key = context.new_random_private_key() self.priv_key = private_key.as_hex() self.pub_key = context.get_public_key(private_key).as_hex() self.signer = CryptoFactory(context).new_signer(private_key) self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6] self._factory = MessageFactory( 'intkey', '1.0', self._namespace, signer=self.signer) self._rest = RestClient(rest_endpoint) def send(self): name = uuid4().hex[:20] txns = [self._factory.create_transaction( cbor.dumps({'Name': name, 'Verb': 'set', 'Value': 1000}), inputs=[self._namespace + self._factory.sha512(name.encode())[-64:]], outputs=[self._namespace + self._factory.sha512(name.encode())[-64:]], deps=[])] self._rest.send_batches(self._factory.create_batch(txns)) def block_list(self): return [(item['header']['block_num'], item['header_signature'], item['header']['signer_public_key']) for item in self._rest.block_list()['data']]
class Client(object): def __init__(self, rest_endpoint): self.priv_key = signer.generate_privkey() self.pub_key = signer.generate_pubkey(self.priv_key) self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6] self._factory = MessageFactory('intkey', '1.0', self._namespace) self._rest = RestClient(rest_endpoint) def send(self): name = uuid4().hex[:20] txns = [ self._factory.create_transaction( cbor.dumps({ 'Name': name, 'Verb': 'set', 'Value': 1000 }), inputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], outputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], deps=[]) ] self._rest.send_batches(self._factory.create_batch(txns)) def block_list(self): return [(item['header']['block_num'], item['header_signature'], item['header']['signer_pubkey']) for item in self._rest.block_list()['data']]
class LispMessageFactory: def __init__(self, private=None, public=None): self.family_name = 'lisp' self._factory = MessageFactory(family_name=self.family_name, family_version='1.0', namespace=LISP_NAMESPACE) def create_transaction(self, cmd, name, expr=''): data = {'cmd': cmd, 'name': name, 'expr': expr} payload = json.dumps(data).encode() addresses = [self.name_to_address(name)] return self._factory.create_transaction(payload=payload, inputs=addresses, outputs=addresses, deps=[]) def create_batch(self, cmd, name, expr): txn = self.create_transaction(cmd, name, expr) return self._factory.create_batch([txn]) def name_to_address(self, name): return LISP_NAMESPACE + self._factory.sha512(name.encode())[:64]
class Client: def __init__(self, rest_endpoint): context = create_context('secp256k1') private_key = context.new_random_private_key() self.priv_key = private_key.as_hex() self.pub_key = context.get_public_key(private_key).as_hex() self.signer = CryptoFactory(context).new_signer(private_key) self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6] self._factory = MessageFactory( 'intkey', '1.0', self._namespace, signer=self.signer) self._rest = RestClient(rest_endpoint) def send(self): name = uuid4().hex[:20] txns = [ self._factory.create_transaction( cbor.dumps({ 'Name': name, 'Verb': 'set', 'Value': 1000 }), inputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], outputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], deps=[]) ] self._rest.send_batches(self._factory.create_batch(txns)) def block_list(self): return [(item['header']['block_num'], item['header_signature'], item['header']['signer_public_key']) for item in self._rest.block_list()['data']]
class OMIMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory(encoding='application/protobuf', family_name=FAMILY_NAME, family_version='1.0', namespace=OMI_ADDRESS_PREFIX, private=private, public=public) self.public_key = self._factory.get_public_key() def create_batch(self, action, **kwargs): return self._factory.create_batch( [self.create_transaction(action, **kwargs)]) def create_transaction(self, action, **kwargs): tag = get_tag(action) obj_type = get_object_type(tag) obj = obj_type(**kwargs) payload = OMITransactionPayload( action=action, data=obj.SerializeToString()).SerializeToString() if tag in (INDIVIDUAL, ORGANIZATION): name = kwargs['name'] elif tag in (WORK, RECORDING): name = kwargs['title'] obj_address = make_omi_address(name, tag) if tag in (INDIVIDUAL, ORGANIZATION): inputs = [obj_address] elif tag in (WORK, RECORDING): inputs = [obj_address] + _reference_addresses(tag, **kwargs) return self._factory.create_transaction(payload, inputs, [obj_address], [])
class SupplyChainMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory(family_name=addressing.FAMILY_NAME, family_version='1.0', namespace=addressing.NAMESPACE, signer=signer) self.public_key = self._factory.get_public_key() self.signer_address = addressing.make_agent_address(self.public_key) def create_agent(self, name): payload = _make_sc_payload(action=SCPayload.CREATE_AGENT, create_agent=CreateAgentAction(name=name)) return self._create_transaction( payload, [self.signer_address], [self.signer_address], ) def create_record_type(self, name, *properties): payload = _make_sc_payload(action=SCPayload.CREATE_RECORD_TYPE, create_record_type=CreateRecordTypeAction( name=name, properties=[ PropertySchema(name=name, data_type=data_type, required=required) for (name, data_type, required) in properties ])) record_type_address = addressing.make_record_type_address(name) return self._create_transaction( payload, inputs=[record_type_address, self.signer_address], outputs=[record_type_address], ) def create_record(self, record_id, record_type, properties_dict): payload = _make_sc_payload( action=SCPayload.CREATE_RECORD, create_record=CreateRecordAction( record_id=record_id, record_type=record_type, properties=[ _make_property_value(name, value) for name, value in properties_dict.items() ])) record_address = addressing.make_record_address(record_id) record_type_address = addressing.make_record_type_address(record_type) property_address_range = \ addressing.make_property_address_range(record_id) inputs = [ record_address, record_type_address, property_address_range, self.signer_address, ] return self._create_transaction(payload, inputs=inputs, outputs=[ record_address, property_address_range, ]) def finalize_record(self, record_id): payload = _make_sc_payload( action=SCPayload.FINALIZE_RECORD, finalize_record=FinalizeRecordAction(record_id=record_id)) record_address = addressing.make_record_address(record_id) return self._create_transaction(payload, [record_address], [record_address]) def update_properties(self, record_id, properties_dict): payload = _make_sc_payload( action=SCPayload.UPDATE_PROPERTIES, update_properties=UpdatePropertiesAction( record_id=record_id, properties=[ _make_property_value(name, value) for name, value in properties_dict.items() ])) record_address = addressing.make_record_address(record_id) property_address_range = \ addressing.make_property_address_range(record_id) inputs = [ record_address, property_address_range, ] return self._create_transaction(payload, inputs=inputs, outputs=[property_address_range]) def create_proposal(self, record_id, receiving_agent, role, properties=None): if properties is None: properties = [] payload = _make_sc_payload(action=SCPayload.CREATE_PROPOSAL, create_proposal=CreateProposalAction( record_id=record_id, receiving_agent=receiving_agent, role=role, properties=properties)) proposal_address = addressing.make_proposal_address( record_id, receiving_agent) receiving_address = addressing.make_agent_address(receiving_agent) record_address = addressing.make_record_address(record_id) return self._create_transaction( payload, inputs=[ proposal_address, record_address, receiving_address, self.signer_address, ], outputs=[proposal_address], ) def answer_proposal(self, record_id, receiving_agent, role, response): payload = _make_sc_payload(action=SCPayload.ANSWER_PROPOSAL, answer_proposal=AnswerProposalAction( record_id=record_id, receiving_agent=receiving_agent, role=role, response=response)) proposal_address = addressing.make_proposal_address( record_id, receiving_agent) record_address = addressing.make_record_address(record_id) property_address_range = addressing.make_property_address_range( record_id) return self._create_transaction( payload, inputs=[ proposal_address, record_address, property_address_range, addressing.RECORD_TYPE_ADDRESS_RANGE, ], outputs=[ proposal_address, record_address, property_address_range, ], ) def revoke_reporter(self, record_id, reporter_id, properties): payload = _make_sc_payload(action=SCPayload.REVOKE_REPORTER, revoke_reporter=RevokeReporterAction( record_id=record_id, reporter_id=reporter_id, properties=properties)) record_address = addressing.make_record_address(record_id) proposal_address = addressing.make_proposal_address( record_id, reporter_id) property_addresses = [ addressing.make_property_address(record_id, property_name) for property_name in properties ] return self._create_transaction( payload, inputs=[ record_address, proposal_address, *property_addresses, ], outputs=[ proposal_address, *property_addresses, ], ) def make_empty_payload(self, public_key): address = addressing.make_agent_address(public_key) return self._create_transaction( payload=SCPayload().SerializeToString(), inputs=[address], outputs=[address]) def _create_transaction(self, payload, inputs, outputs): return self._factory.create_transaction(payload, inputs, outputs, []) def create_batch(self, transaction): return self._factory.create_batch([transaction])
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 XoMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory(encoding="csv-utf8", family_name="xo", family_version="1.0", namespace="", private=private, public=public) self._factory.namespace = self._factory.sha512( "xo".encode("utf-8"))[0:6] def _game_to_address(self, game): return self._factory.namespace + \ self._factory.sha512(game.encode()) 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, game, action, space=None): payload = ",".join([str(game), str(action), str(space)]).encode() addresses = [self._game_to_address(game)] return self._factory.create_transaction(payload, addresses, addresses, []) 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([board, state, player1, player2, game]).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([board, state, player1, player2, game]).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 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_transaction(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_transaction(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_transaction(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_transaction(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)