class Client(object): def __init__(self, rest_endpoint): self.priv_key = signer.generate_privkey() self.pub_key = signer.generate_pubkey(self.priv_key) self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6] self._factory = MessageFactory('intkey', '1.0', self._namespace) self._rest = RestClient(rest_endpoint) def send(self): name = uuid4().hex[:20] txns = [ self._factory.create_transaction( cbor.dumps({ 'Name': name, 'Verb': 'set', 'Value': 1000 }), inputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], outputs=[ self._namespace + self._factory.sha512(name.encode())[-64:] ], deps=[]) ] self._rest.send_batches(self._factory.create_batch(txns)) def block_list(self): return [(item['header']['block_num'], item['header_signature'], item['header']['signer_pubkey']) for item in self._rest.block_list()['data']]
class Client(object): def __init__(self, rest_endpoint): context = create_context('secp256k1') private_key = context.new_random_private_key() self.priv_key = private_key.as_hex() self.pub_key = context.get_public_key(private_key).as_hex() self.signer = CryptoFactory(context).new_signer(private_key) self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6] self._factory = MessageFactory( 'intkey', '1.0', self._namespace, signer=self.signer) self._rest = RestClient(rest_endpoint) def send(self): name = uuid4().hex[:20] txns = [self._factory.create_transaction( cbor.dumps({'Name': name, 'Verb': 'set', 'Value': 1000}), inputs=[self._namespace + self._factory.sha512(name.encode())[-64:]], outputs=[self._namespace + self._factory.sha512(name.encode())[-64:]], deps=[])] self._rest.send_batches(self._factory.create_batch(txns)) def block_list(self): return [(item['header']['block_num'], item['header_signature'], item['header']['signer_public_key']) for item in self._rest.block_list()['data']]
def test__create_signature(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) name = uuid4().hex[:20] payload = cbor.dumps({'Name': name, 'Verb': 'set', 'Value': 1000}) inputs = battleshipMessage.namespaces[0] + MessageFactory.sha512( name.encode())[-64:] outputs = battleshipMessage.namespaces[0] + MessageFactory.sha512( name.encode())[-64:] deps = [] header = battleshipMessage._create_transaction_header( payload, inputs, outputs, deps) # result = benchmark(MessageFactory._create_signature, battleshipMessage, header) return
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 test_create_tp_process_request(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) name = uuid4().hex[:20] benchmark( MessageFactory.create_tp_process_request, battleshipMessage, cbor.dumps({ 'Name': name, 'Verb': 'set', 'Value': 1000 }), battleshipMessage.namespaces[0] + MessageFactory.sha512(name.encode())[-64:], battleshipMessage.namespaces[0] + MessageFactory.sha512(name.encode())[-64:], []) return
def test__create_header_and_sig(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) name = uuid4().hex[:20] result = benchmark( MessageFactory._create_header_and_sig, battleshipMessage, cbor.dumps({ 'Name': name, 'Verb': 'set', 'Value': 1000 }), battleshipMessage.namespaces[0] + MessageFactory.sha512(name.encode())[-64:], battleshipMessage.namespaces[0] + MessageFactory.sha512(name.encode())[-64:], []) return
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(family_name="battleship", family_version="1.0", namespace=MessageFactory.sha512( "battleship".encode("utf-8"))[0:6], private=private, public=public)
def __init__(self, signer=None): self._factory = MessageFactory( family_name="simplewallet", family_version="1.0", namespace=MessageFactory.sha512( "simplewallet".encode("utf-8"))[0:6], signer=signer)
def test_create_tp_response(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) result = benchmark(MessageFactory.create_tp_response, battleshipMessage, "OK") return
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="crowdfunding", family_version="1.0", namespace=MessageFactory.sha512( "crowdfunding".encode("utf-8"))[0:6], signer=signer)
class LispMessageFactory: def __init__(self, private=None, public=None): self.family_name = 'lisp' self._factory = MessageFactory(family_name=self.family_name, family_version='1.0', namespace=LISP_NAMESPACE) def create_transaction(self, cmd, name, expr=''): data = {'cmd': cmd, 'name': name, 'expr': expr} payload = json.dumps(data).encode() addresses = [self.name_to_address(name)] return self._factory.create_transaction(payload=payload, inputs=addresses, outputs=addresses, deps=[]) def create_batch(self, cmd, name, expr): txn = self.create_transaction(cmd, name, expr) return self._factory.create_batch([txn]) def name_to_address(self, name): return LISP_NAMESPACE + self._factory.sha512(name.encode())[:64]
def test_create_add_event_request(benchmark): key = "policy1" battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) benchmark(MessageFactory.create_add_event_request, battleshipMessage, "settings/update", [("update", key)]) return
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, private=None, public=None): self._factory = MessageFactory(family_name="battleship", family_version="1.0", namespace=MessageFactory.sha512( "battleship".encode("utf-8"))[0:6], private=private, public=public) def _game_to_address(self, game): return self._factory.namespace + \ self._factory.sha512(game.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, payload): addresses = [self._game_to_address(payload['Name'])] return txn_function( json.dumps(payload).encode(), addresses, addresses, []) def create_tp_process_request(self, payload): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, payload) def create_transaction(self, payload): txn_function = self._factory.create_transaction return self._create_txn(txn_function, payload) def create_get_request(self, name): addresses = [self._game_to_address(name)] return self._factory.create_get_request(addresses) def create_get_response(self, game, payload=None): if payload: address = self._game_to_address(game) data = json.dumps({game: payload}).encode() return self._factory.create_get_response({address: data}) return self._factory.create_get_response({}) def create_set_request(self, game, new_state): address = self._game_to_address(game) data = json.dumps({game: new_state}).encode() return self._factory.create_set_request({address: data}) def create_set_response(self, game): addresses = [self._game_to_address(game)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()
def __init__(self, private=None, public=None): self._factory = MessageFactory( encoding="csv-utf8", family_name="xo", family_version="1.0", namespace=MessageFactory.sha512("xo".encode("utf-8"))[0:6], private=private, public=public )
def test_create_set_response(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) context = create_context("secp256k1") publicKey = battleshipMessage.get_public_key() address = battleshipMessage.namespaces[0] + MessageFactory.sha256( publicKey.encode("utf-8")) benchmark(MessageFactory.create_set_response, battleshipMessage, [address]) return
class MktMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory(family_name="mkt", family_version="1.0", namespace=MessageFactory.sha512( "mkt".encode("utf-8"))[0:6], signer=signer) def _house_to_address(self, house): return self._factory.namespace + \ self._factory.sha512(house.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, house, action, owner): payload = ",".join([str(house), str(action), str(owner)]).encode() addresses = [self._house_to_address(house)] return txn_function(payload, addresses, addresses, []) def create_tp_process_request(self, action, house, owner): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, house, action, owner) def create_transaction(self, house, action, owner): txn_function = self._factory.create_transaction return self._create_txn(txn_function, house, action, owner) def create_get_request(self, house): addresses = [self._house_to_address(house)] return self._factory.create_get_request(addresses) def create_get_response(self, house, owner): address = self._house_to_address(house) data = ",".join([house, owner]).encode() return self._factory.create_get_response({address: data}) def create_set_request(self, house, owner): address = self._house_to_address(house) data = ",".join([house, owner]).encode() return self._factory.create_set_request({address: data}) def create_set_response(self, house): addresses = [self._house_to_address(house)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()
def test_create_set_request(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) context = create_context("secp256k1") publicKey = battleshipMessage.get_public_key() address = battleshipMessage.namespaces[0] + MessageFactory.sha256( publicKey.encode("utf-8")) data = ValidatorMap().SerializeToString() benchmark(MessageFactory.create_set_request, battleshipMessage, {address: data}) return
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 test_init_xo_message(benchmark): result = benchmark(MessageFactory, "xo", "1.0", MessageFactory.sha512("xo".encode("utf-8"))[0:6], None) return
def test_get_public_key(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) result = benchmark(MessageFactory.get_public_key, battleshipMessage) return
def make_xo_address(unique_value): return XO_NAMESPACE + MessageFactory.sha512(unique_value.encode())[:64]
def make_intkey_address(unique_value): return INTKEY_NAMESPACE + MessageFactory.sha512( unique_value.encode())[-64:]
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] },
def make_intkey_address(unique_value): return INTKEY_NAMESPACE + MessageFactory.sha512( unique_value.encode())[-64:]
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)
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 SoceMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory( family_name="soce", family_version="1.0", namespace=MessageFactory.sha512("soce".encode("utf-8"))[0:6], signer=signer) def voting_voter_to_address(self, name_id): return self._factory.namespace + \ self._factory.sha512(name_id.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, action = None, name_id = None, configurations_preferences_id = None, sc_method = None): payload = ";".join([ str(action), str(name_id), str(configurations_preferences_id), str(sc_method) ]).encode() print('txn en camino!', payload) addresses = [self.voting_voter_to_address(name_id), self.voting_voter_to_address(configurations_preferences_id)] return txn_function(payload, addresses, addresses, []) def create_tp_process_request(self, action = None, name_id = None, configurations_preferences_id = None, sc_method = None): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, action, name_id, configurations_preferences_id, sc_method) def create_transaction(self, action = None, name_id = None, configurations_preferences_id = None, sc_method = None): txn_function = self._factory.create_transaction return self._create_txn(txn_function, action, name_id, configurations_preferences_id, sc_method) def create_get_request(self, name_id): addresses = [self.voting_voter_to_address(name_id)] return self._factory.create_get_request(addresses) def create_get_response(self, name_id, value = None): address = self.voting_voter_to_address(name_id) data = None if value is not None: data = ";".join([name_id, value]).encode() else: data = None return self._factory.create_get_response({address: data}) def create_set_request(self, action = None, name_id = None, configurations_preferences = None, sc_method = None): address = self.voting_voter_to_address(name_id) print('create_set_request') data = None if value is not None: data = ";".join([str(action), str(name_id), str(configurations_preferences), str(sc_method)]).encode() else: data = None return self._factory.create_set_request({address: data}) def create_set_response(self, name_id): addresses = [self.voting_voter_to_address(name_id)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()
class 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 __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 XoMessageFactory: def __init__(self, private=None, public=None): self._factory = MessageFactory(encoding="csv-utf8", family_name="xo", family_version="1.0", namespace=MessageFactory.sha512( "xo".encode("utf-8"))[0:6], private=private, public=public) def _game_to_address(self, game): return self._factory.namespace + \ self._factory.sha512(game.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, game, action, space=None): payload = ",".join([str(game), str(action), str(space)]).encode() addresses = [self._game_to_address(game)] return txn_function(payload, addresses, addresses, []) def create_tp_process_request(self, action, game, space=None): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, game, action, space) def create_transaction(self, game, action, space=None): txn_function = self._factory.create_transaction return self._create_txn(txn_function, game, action, space) def create_get_request(self, game): addresses = [self._game_to_address(game)] return self._factory.create_get_request(addresses) def create_get_response(self, game, board="---------", state="P1-NEXT", player1="", player2=""): address = self._game_to_address(game) data = None if board is not None: data = ",".join([game, board, state, player1, player2]).encode() else: data = None return self._factory.create_get_response({address: data}) def create_set_request(self, game, board="---------", state="P1-NEXT", player1="", player2=""): address = self._game_to_address(game) data = None if state is not None: data = ",".join([game, board, state, player1, player2]).encode() else: data = None return self._factory.create_get_response({address: data}) def create_set_response(self, game): addresses = [self._game_to_address(game)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()
def make_xo_address(unique_value): return XO_NAMESPACE + MessageFactory.sha512(unique_value.encode())[:64]
def test_create_add_event_response(benchmark): battleshipMessage = MessageFactory( "battleship", "1.0", MessageFactory.sha512("battleship".encode("utf-8"))[0:6], None) benchmark(MessageFactory.create_add_event_response, battleshipMessage) return
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 CertMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory(family_name="cert", family_version="1.0", namespace=MessageFactory.sha512( "cert".encode("utf-8"))[0:6], signer=signer) def _certificate_to_address(self, certificate): return self._factory.namespace + \ self._factory.sha512(certificate.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, certificate, action, space=None): payload = ",".join([str(certificate), str(action), str(space)]).encode() addresses = [self._certificate_to_address(certificate)] return txn_function(payload, addresses, addresses, []) def create_tp_process_request(self, action, certificate, space=None): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, certificate, action, space) def create_transaction(self, certificate, action, space=None): txn_function = self._factory.create_transaction return self._create_txn(txn_function, certificate, action, space) def create_get_request(self, game): addresses = [self._certificate_to_address(game)] return self._factory.create_get_request(addresses) # Todo: change def create_get_response(self, game, board="---------", state="P1-NEXT", player1="", player2=""): address = self._certificate_to_address(game) data = None if board is not None: data = ",".join([game, board, state, player1, player2]).encode() else: data = None return self._factory.create_get_response({address: data}) def create_set_request(self, game, board="---------", state="P1-NEXT", player1="", player2=""): address = self._certificate_to_address(game) if state is not None: data = ",".join([game, board, state, player1, player2]).encode() else: data = None return self._factory.create_set_request({address: data}) def create_set_response(self, certificate): addresses = [self._certificate_to_address(certificate)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()
class DQMessageFactory: def __init__(self, signer=None): self._factory = MessageFactory(family_name="dq", family_version="1.0", namespace=MessageFactory.sha512( "dq".encode("utf-8"))[0:6], signer=signer) def _quality_to_address(self, quality): return self._factory.namespace + \ self._factory.sha512(quality.encode())[0:64] def create_tp_register(self): return self._factory.create_tp_register() def create_tp_response(self, status): return self._factory.create_tp_response(status) def _create_txn(self, txn_function, quality, action): payload = ",".join([str(quality), str(action)]).encode() addresses = [self._quality_to_address(quality)] return txn_function(payload, addresses, addresses, []) def create_tp_process_request(self, action, quality): txn_function = self._factory.create_tp_process_request return self._create_txn(txn_function, quality, action) def create_transaction(self, quality, action): txn_function = self._factory.create_transaction return self._create_txn(txn_function, quality, action) def create_get_request(self, quality): addresses = [self._quality_to_address(quality)] return self._factory.create_get_request(addresses) # def create_get_response( # self, game, board="---------", state="P1-NEXT", player1="", player2="" # ): # address = self._game_to_address(game) # # data = None # if board is not None: # data = ",".join([game, board, state, player1, player2]).encode() # else: # data = None # # return self._factory.create_get_response({address: data}) # # def create_set_request( # self, game, board="---------", state="P1-NEXT", player1="", player2="" # ): # address = self._game_to_address(game) # # data = None # if state is not None: # data = ",".join([game, board, state, player1, player2]).encode() # else: # data = None # # return self._factory.create_set_request({address: data}) def create_set_response(self, quality): addresses = [self._quality_to_address(quality)] return self._factory.create_set_response(addresses) def get_public_key(self): return self._factory.get_public_key()