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 __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 )
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()
def __init__(self, signer=None): self._factory = MessageFactory( family_name="sawtooth_identity", family_version="1.0", namespace="00001d", signer=signer, )
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 )
def __init__(self, private=None, public=None): self._factory = MessageFactory( encoding='application/cbor', family_name='intkey', family_version='1.0', namespace=INTKEY_ADDRESS_PREFIX, private=private, public=public )
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 )
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']]
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 __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)
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 __init__(self, signer=None): self._factory = MessageFactory(family_name="sawtooth_settings", family_version="1.0", namespace="000000", signer=signer)
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()
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)
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 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()
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)
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 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, 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_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()
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)
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 IntkeyMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory(encoding='application/cbor', family_name='intkey', family_version='1.0', namespace=INTKEY_ADDRESS_PREFIX, private=private, public=public) 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)
def __init__(self, signer=None): self._factory = MessageFactory( family_name='intkey', family_version='1.0', namespace=INTKEY_ADDRESS_PREFIX, signer=signer)
def __init__(self, signer=None): self._factory = MessageFactory( family_name=FAMILY_NAME, family_version=FAMILY_VER, namespace=SMART_BGT_ADDRESS_PREFIX, signer=signer)
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 TrackAndTradeMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory(encoding='application/protobuf', family_name=addressing.FAMILY_NAME, family_version='1.0', namespace=addressing.NAMESPACE, private=private, public=public) self.public_key = self._factory.get_public_key() self.private_key = self._factory.get_private_key() self.signer_address = addressing.make_agent_address(self.public_key) def create_agent(self, name): payload = _make_tt_payload(action=TTPayload.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_tt_payload(action=TTPayload.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_tt_payload( action=TTPayload.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_tt_payload( action=TTPayload.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_tt_payload( action=TTPayload.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_tt_payload(action=TTPayload.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_tt_payload(action=TTPayload.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_tt_payload(action=TTPayload.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=TTPayload().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])
def __init__(self, signer=None): self._factory = MessageFactory( family_name="sawtooth_settings", family_version="1.0", namespace="000000", signer=signer)
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)
def __init__(self, signer=None): self._factory = MessageFactory( family_name='registry', family_version='0.1', namespace=INTKEY_ADDRESS_PREFIX, signer=signer)
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)
def make_intkey_address(unique_value): return INTKEY_NAMESPACE + MessageFactory.sha512( unique_value.encode())[-64:]
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()
def assert_able_to_send_batch(self, txns, *transactor_family_pairs): for transactor, family in transactor_family_pairs: transactor.send(family_name=family, transactions=txns) def assert_not_able_to_send(self, *transactor_family_pairs): for transactor, family in transactor_family_pairs: with self.assertRaises(Exception): transactor.send(family) def assert_not_able_to_send_batch(self, txns, *transactor_family_pairs): for transactor, family in transactor_family_pairs: with self.assertRaises(Exception): transactor.send(family, txns) INTKEY_NAMESPACE = MessageFactory.sha512('intkey'.encode())[:6] XO_NAMESPACE = MessageFactory.sha512('xo'.encode())[:6] # pylint: disable=invalid-name class Families(enum.Enum): INTKEY = 1 XO = 2 FAMILY_CONFIG = { Families.INTKEY: { 'family_name': 'intkey', 'family_version': '1.0', 'namespace': MessageFactory.sha256('intkey'.encode())[:6] },
class SettingsMessageFactory(object): 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 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 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 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()})
def get_message_factory(self, signer=None): return MessageFactory(family_name=self.family_name, family_version=self.family_versions[-1], namespace=self.namespaces[-1], signer=signer)
def __init__(self, private=None, public=None): self._factory = MessageFactory(family_name='intkey', family_version='1.0', namespace=INTKEY_ADDRESS_PREFIX, private=private, public=public)
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 SmartBgtMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory( family_name=FAMILY_NAME, family_version=FAMILY_VER, namespace=SMART_BGT_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_smart_bgt_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_smart_bgt_address(name)] return self._factory.create_get_request(addresses) def create_get_response(self, name, value): address = make_smart_bgt_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_smart_bgt_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_smart_bgt_address(name)] return self._factory.create_set_response(addresses)
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()
def make_xo_address(unique_value): return XO_NAMESPACE + MessageFactory.sha512(unique_value.encode())[:64]
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 __init__(self, private=None, public=None): self._factory = MessageFactory(family_name="sawtooth_settings", family_version="1.0", namespace="000000", private=private, public=public)
class BattleshipMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory( encoding="json-utf8", 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 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)