class Client(object):
def __init__(self, rest_endpoint):
context = create_context('secp256k1')
private_key = context.new_random_private_key()
self.priv_key = private_key.as_hex()
self.pub_key = context.get_public_key(private_key).as_hex()
self.signer = CryptoFactory(context).new_signer(private_key)
self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6]
self._factory = MessageFactory(
'intkey',
'1.0',
self._namespace,
signer=self.signer)
self._rest = RestClient(rest_endpoint)
def send(self):
name = uuid4().hex[:20]
txns = [self._factory.create_transaction(
cbor.dumps({'Name': name,
'Verb': 'set',
'Value': 1000}),
inputs=[self._namespace + self._factory.sha512(name.encode())[-64:]],
outputs=[self._namespace + self._factory.sha512(name.encode())[-64:]],
deps=[])]
self._rest.send_batches(self._factory.create_batch(txns))
def block_list(self):
return [(item['header']['block_num'],
item['header_signature'],
item['header']['signer_public_key'])
for item in self._rest.block_list()['data']]
class Client(object):
def __init__(self, rest_endpoint):
self.priv_key = signer.generate_privkey()
self.pub_key = signer.generate_pubkey(self.priv_key)
self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6]
self._factory = MessageFactory('intkey', '1.0', self._namespace)
self._rest = RestClient(rest_endpoint)
def send(self):
name = uuid4().hex[:20]
txns = [
self._factory.create_transaction(
cbor.dumps({
'Name': name,
'Verb': 'set',
'Value': 1000
}),
inputs=[
self._namespace + self._factory.sha512(name.encode())[-64:]
],
outputs=[
self._namespace + self._factory.sha512(name.encode())[-64:]
],
deps=[])
]
self._rest.send_batches(self._factory.create_batch(txns))
def block_list(self):
return [(item['header']['block_num'], item['header_signature'],
item['header']['signer_pubkey'])
for item in self._rest.block_list()['data']]
class LispMessageFactory:
def __init__(self, private=None, public=None):
self.family_name = 'lisp'
self._factory = MessageFactory(family_name=self.family_name,
family_version='1.0',
namespace=LISP_NAMESPACE)
def create_transaction(self, cmd, name, expr=''):
data = {'cmd': cmd, 'name': name, 'expr': expr}
payload = json.dumps(data).encode()
addresses = [self.name_to_address(name)]
return self._factory.create_transaction(payload=payload,
inputs=addresses,
outputs=addresses,
deps=[])
def create_batch(self, cmd, name, expr):
txn = self.create_transaction(cmd, name, expr)
return self._factory.create_batch([txn])
def name_to_address(self, name):
return LISP_NAMESPACE + self._factory.sha512(name.encode())[:64]
class Client:
def __init__(self, rest_endpoint):
context = create_context('secp256k1')
private_key = context.new_random_private_key()
self.priv_key = private_key.as_hex()
self.pub_key = context.get_public_key(private_key).as_hex()
self.signer = CryptoFactory(context).new_signer(private_key)
self._namespace = hashlib.sha512('intkey'.encode()).hexdigest()[:6]
self._factory = MessageFactory(
'intkey',
'1.0',
self._namespace,
signer=self.signer)
self._rest = RestClient(rest_endpoint)
def send(self):
name = uuid4().hex[:20]
txns = [
self._factory.create_transaction(
cbor.dumps({
'Name': name,
'Verb': 'set',
'Value': 1000
}),
inputs=[
self._namespace + self._factory.sha512(name.encode())[-64:]
],
outputs=[
self._namespace + self._factory.sha512(name.encode())[-64:]
],
deps=[])
]
self._rest.send_batches(self._factory.create_batch(txns))
def block_list(self):
return [(item['header']['block_num'],
item['header_signature'],
item['header']['signer_public_key'])
for item in self._rest.block_list()['data']]
class OMIMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding='application/protobuf',
family_name=FAMILY_NAME,
family_version='1.0',
namespace=OMI_ADDRESS_PREFIX,
private=private,
public=public)
self.public_key = self._factory.get_public_key()
def create_batch(self, action, **kwargs):
return self._factory.create_batch(
[self.create_transaction(action, **kwargs)])
def create_transaction(self, action, **kwargs):
tag = get_tag(action)
obj_type = get_object_type(tag)
obj = obj_type(**kwargs)
payload = OMITransactionPayload(
action=action, data=obj.SerializeToString()).SerializeToString()
if tag in (INDIVIDUAL, ORGANIZATION):
name = kwargs['name']
elif tag in (WORK, RECORDING):
name = kwargs['title']
obj_address = make_omi_address(name, tag)
if tag in (INDIVIDUAL, ORGANIZATION):
inputs = [obj_address]
elif tag in (WORK, RECORDING):
inputs = [obj_address] + _reference_addresses(tag, **kwargs)
return self._factory.create_transaction(payload, inputs, [obj_address],
[])
class SupplyChainMessageFactory:
def __init__(self, signer=None):
self._factory = MessageFactory(family_name=addressing.FAMILY_NAME,
family_version='1.0',
namespace=addressing.NAMESPACE,
signer=signer)
self.public_key = self._factory.get_public_key()
self.signer_address = addressing.make_agent_address(self.public_key)
def create_agent(self, name):
payload = _make_sc_payload(action=SCPayload.CREATE_AGENT,
create_agent=CreateAgentAction(name=name))
return self._create_transaction(
payload,
[self.signer_address],
[self.signer_address],
)
def create_record_type(self, name, *properties):
payload = _make_sc_payload(action=SCPayload.CREATE_RECORD_TYPE,
create_record_type=CreateRecordTypeAction(
name=name,
properties=[
PropertySchema(name=name,
data_type=data_type,
required=required)
for (name, data_type,
required) in properties
]))
record_type_address = addressing.make_record_type_address(name)
return self._create_transaction(
payload,
inputs=[record_type_address, self.signer_address],
outputs=[record_type_address],
)
def create_record(self, record_id, record_type, properties_dict):
payload = _make_sc_payload(
action=SCPayload.CREATE_RECORD,
create_record=CreateRecordAction(
record_id=record_id,
record_type=record_type,
properties=[
_make_property_value(name, value)
for name, value in properties_dict.items()
]))
record_address = addressing.make_record_address(record_id)
record_type_address = addressing.make_record_type_address(record_type)
property_address_range = \
addressing.make_property_address_range(record_id)
inputs = [
record_address,
record_type_address,
property_address_range,
self.signer_address,
]
return self._create_transaction(payload,
inputs=inputs,
outputs=[
record_address,
property_address_range,
])
def finalize_record(self, record_id):
payload = _make_sc_payload(
action=SCPayload.FINALIZE_RECORD,
finalize_record=FinalizeRecordAction(record_id=record_id))
record_address = addressing.make_record_address(record_id)
return self._create_transaction(payload, [record_address],
[record_address])
def update_properties(self, record_id, properties_dict):
payload = _make_sc_payload(
action=SCPayload.UPDATE_PROPERTIES,
update_properties=UpdatePropertiesAction(
record_id=record_id,
properties=[
_make_property_value(name, value)
for name, value in properties_dict.items()
]))
record_address = addressing.make_record_address(record_id)
property_address_range = \
addressing.make_property_address_range(record_id)
inputs = [
record_address,
property_address_range,
]
return self._create_transaction(payload,
inputs=inputs,
outputs=[property_address_range])
def create_proposal(self,
record_id,
receiving_agent,
role,
properties=None):
if properties is None:
properties = []
payload = _make_sc_payload(action=SCPayload.CREATE_PROPOSAL,
create_proposal=CreateProposalAction(
record_id=record_id,
receiving_agent=receiving_agent,
role=role,
properties=properties))
proposal_address = addressing.make_proposal_address(
record_id, receiving_agent)
receiving_address = addressing.make_agent_address(receiving_agent)
record_address = addressing.make_record_address(record_id)
return self._create_transaction(
payload,
inputs=[
proposal_address,
record_address,
receiving_address,
self.signer_address,
],
outputs=[proposal_address],
)
def answer_proposal(self, record_id, receiving_agent, role, response):
payload = _make_sc_payload(action=SCPayload.ANSWER_PROPOSAL,
answer_proposal=AnswerProposalAction(
record_id=record_id,
receiving_agent=receiving_agent,
role=role,
response=response))
proposal_address = addressing.make_proposal_address(
record_id, receiving_agent)
record_address = addressing.make_record_address(record_id)
property_address_range = addressing.make_property_address_range(
record_id)
return self._create_transaction(
payload,
inputs=[
proposal_address,
record_address,
property_address_range,
addressing.RECORD_TYPE_ADDRESS_RANGE,
],
outputs=[
proposal_address,
record_address,
property_address_range,
],
)
def revoke_reporter(self, record_id, reporter_id, properties):
payload = _make_sc_payload(action=SCPayload.REVOKE_REPORTER,
revoke_reporter=RevokeReporterAction(
record_id=record_id,
reporter_id=reporter_id,
properties=properties))
record_address = addressing.make_record_address(record_id)
proposal_address = addressing.make_proposal_address(
record_id, reporter_id)
property_addresses = [
addressing.make_property_address(record_id, property_name)
for property_name in properties
]
return self._create_transaction(
payload,
inputs=[
record_address,
proposal_address,
*property_addresses,
],
outputs=[
proposal_address,
*property_addresses,
],
)
def make_empty_payload(self, public_key):
address = addressing.make_agent_address(public_key)
return self._create_transaction(
payload=SCPayload().SerializeToString(),
inputs=[address],
outputs=[address])
def _create_transaction(self, payload, inputs, outputs):
return self._factory.create_transaction(payload, inputs, outputs, [])
def create_batch(self, transaction):
return self._factory.create_batch([transaction])
class IntkeyMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="application/cbor",
family_name="intkey",
family_version="1.0",
namespace="",
private=private,
public=public)
self._factory.namespace = self._factory.sha512(
"intkey".encode("utf-8"))[0:6]
def _dumps(self, obj):
return cbor.dumps(obj, sort_keys=True)
def _loads(self, data):
return cbor.loads(data)
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha512(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def create_transaction(self, verb, name, value):
payload = self._dumps({"Verb": verb, "Name": name, "Value": value})
addresses = [self._key_to_address(name)]
return self._factory.create_transaction(payload, addresses, addresses,
[])
def create_get_request(self, name):
addresses = [self._key_to_address(name)]
return self._factory.create_get_request(addresses)
def create_get_response(self, name, value):
address = self._key_to_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, name, value):
address = self._key_to_address(name)
if value is not None:
data = self._dumps({name: value})
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, name):
addresses = [self._key_to_address(name)]
return self._factory.create_set_response(addresses)
class XoMessageFactory:
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="csv-utf8",
family_name="xo",
family_version="1.0",
namespace="",
private=private,
public=public)
self._factory.namespace = self._factory.sha512(
"xo".encode("utf-8"))[0:6]
def _game_to_address(self, game):
return self._factory.namespace + \
self._factory.sha512(game.encode())
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def create_transaction(self, game, action, space=None):
payload = ",".join([str(game), str(action), str(space)]).encode()
addresses = [self._game_to_address(game)]
return self._factory.create_transaction(payload, addresses, addresses,
[])
def create_get_request(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_get_request(addresses)
def create_get_response(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._game_to_address(game)
data = None
if board is not None:
data = ",".join([board, state, player1, player2, game]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self,
game,
board="---------",
state="P1-NEXT",
player1="",
player2=""):
address = self._game_to_address(game)
data = None
if state is not None:
data = ",".join([board, state, player1, player2, game]).encode()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_response(self, game):
addresses = [self._game_to_address(game)]
return self._factory.create_set_response(addresses)
def get_public_key(self):
return self._factory.get_public_key()
class ConfigMessageFactory(object):
def __init__(self, private=None, public=None):
self._factory = MessageFactory(encoding="application/protobuf",
family_name="sawtooth_config",
family_version="1.0",
namespace="000000",
private=private,
public=public)
@property
def public_key(self):
return self._factory.get_public_key()
def _key_to_address(self, key):
return self._factory.namespace + \
self._factory.sha256(key.encode("utf-8"))
def create_tp_register(self):
return self._factory.create_tp_register()
def create_tp_response(self, status):
return self._factory.create_tp_response(status)
def _create_transaction(self, setting, payload):
inputs = [
self._key_to_address('sawtooth.config.authorization_type'),
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address('sawtooth.config.vote.authorized_keys'),
self._key_to_address('sawtooth.config.vote.approval_threshold'),
self._key_to_address(setting)
]
outputs = [
self._key_to_address('sawtooth.config.vote.proposals'),
self._key_to_address(setting)
]
return self._factory.create_transaction(payload.SerializeToString(),
inputs, outputs, [])
def create_proposal_transaction(self, setting, value, nonce):
proposal = ConfigProposal(setting=setting, value=value, nonce=nonce)
payload = ConfigPayload(action=ConfigPayload.PROPOSE,
data=proposal.SerializeToString())
return self._create_transaction(setting, payload)
def create_vote_proposal(self, proposal_id, setting, vote):
vote = ConfigVote(proposal_id=proposal_id, vote=vote)
payload = ConfigPayload(action=ConfigPayload.VOTE,
data=vote.SerializeToString())
return self._create_transaction(setting, payload)
def create_get_request(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_get_request(addresses)
def create_get_response(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_get_response({address: data})
def create_set_request(self, setting, value=None):
address = self._key_to_address(setting)
if value is not None:
entry = Setting.Entry(key=setting, value=value)
data = Setting(entries=[entry]).SerializeToString()
else:
data = None
return self._factory.create_set_request({address: data})
def create_set_response(self, setting):
addresses = [self._key_to_address(setting)]
return self._factory.create_set_response(addresses)