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