def make_create_agent_transaction(transaction_signer, batch_signer, name,
timestamp):
"""Make a CreateAgentAction transaction and wrap it in a batch
Args:
transaction_signer (sawtooth_signing.Signer): The transaction key pair
batch_signer (sawtooth_signing.Signer): The batch key pair
name (str): The agent's name
timestamp (int): Unix UTC timestamp of when the agent is created
Returns:
batch_pb2.Batch: The transaction wrapped in a batch
"""
agent_address = addresser.get_agent_address(
transaction_signer.get_public_key().as_hex())
inputs = [agent_address]
outputs = [agent_address]
action = payload_pb2.CreateAgentAction(name=name)
payload = payload_pb2.SimpleSupplyPayload(
action=payload_pb2.SimpleSupplyPayload.CREATE_AGENT,
create_agent=action,
timestamp=timestamp)
payload_bytes = payload.SerializeToString()
return _make_batch(payload_bytes=payload_bytes,
inputs=inputs,
outputs=outputs,
transaction_signer=transaction_signer,
batch_signer=batch_signer)
def set_agent(self, public_key, email, name, timestamp):
"""Creates a new agent in state
Args:
public_key (str): The public key of the agent
email (str): The email address of the agent
name (str): The human-readable name of the agent
timestamp (int): Unix UTC timestamp of when the agent was created
"""
address = addresser.get_agent_address(public_key)
agent = agent_pb2.Agent(public_key=public_key,
email=email,
name=name,
timestamp=timestamp)
container = agent_pb2.AgentContainer()
state_entries = self._context.get_state(addresses=[address],
timeout=self._timeout)
if state_entries:
container.ParseFromString(state_entries[0].data)
container.entries.extend([agent])
data = container.SerializeToString()
updated_state = {}
updated_state[address] = data
self._context.set_state(updated_state, timeout=self._timeout)
def make_transfer_record_transaction(transaction_signer,
batch_signer,
receiving_agent,
record_id,
timestamp):
"""Make a CreateRecordAction transaction and wrap it in a batch
Args:
transaction_signer (sawtooth_signing.Signer): The transaction key pair
batch_signer (sawtooth_signing.Signer): The batch key pair
receiving_agent (str): Public key of the agent receiving the record
record_id (str): Unique ID of the record
timestamp (int): Unix UTC timestamp of when the record is transferred
Returns:
batch_pb2.Batch: The transaction wrapped in a batch
"""
sending_agent_address = addresser.get_agent_address(
transaction_signer.get_public_key().as_hex())
receiving_agent_address = addresser.get_agent_address(receiving_agent)
record_address = addresser.get_record_address(record_id)
inputs = [sending_agent_address, receiving_agent_address, record_address]
outputs = [record_address]
action = payload_pb2.TransferRecordAction(
record_id=record_id,
receiving_agent=receiving_agent)
payload = payload_pb2.SimpleSupplyPayload(
action=payload_pb2.SimpleSupplyPayload.TRANSFER_RECORD,
transfer_record=action,
timestamp=timestamp)
payload_bytes = payload.SerializeToString()
return _make_batch(
payload_bytes=payload_bytes,
inputs=inputs,
outputs=outputs,
transaction_signer=transaction_signer,
batch_signer=batch_signer)
def make_create_record_transaction(transaction_signer,
batch_signer,
latitude,
longitude,
record_id,
timestamp):
"""Make a CreateRecordAction transaction and wrap it in a batch
Args:
transaction_signer (sawtooth_signing.Signer): The transaction key pair
batch_signer (sawtooth_signing.Signer): The batch key pair
latitude (int): Initial latitude of the record
longitude (int): Initial latitude of the record
record_id (str): Unique ID of the record
timestamp (int): Unix UTC timestamp of when the agent is created
Returns:
batch_pb2.Batch: The transaction wrapped in a batch
"""
inputs = [
addresser.get_agent_address(
transaction_signer.get_public_key().as_hex()),
addresser.get_record_address(record_id)
]
outputs = [addresser.get_record_address(record_id)]
action = payload_pb2.CreateRecordAction(
record_id=record_id,
latitude=latitude,
longitude=longitude)
payload = payload_pb2.SimpleSupplyPayload(
action=payload_pb2.SimpleSupplyPayload.CREATE_RECORD,
create_record=action,
timestamp=timestamp)
payload_bytes = payload.SerializeToString()
return _make_batch(
payload_bytes=payload_bytes,
inputs=inputs,
outputs=outputs,
transaction_signer=transaction_signer,
batch_signer=batch_signer)
def make_update_record_transaction(transaction_signer, batch_signer, seq, ts,
device, ddata, dsize, dhash, record_id,
timestamp):
"""Make a CreateRecordAction transaction and wrap it in a batch
Args:
transaction_signer (sawtooth_signing.Signer): The transaction key pair
batch_signer (sawtooth_signing.Signer): The batch key pair
latitude (int): Updated latitude of the location
longitude (int): Updated longitude of the location
record_id (str): Unique ID of the record
timestamp (int): Unix UTC timestamp of when the record is updated
Returns:
batch_pb2.Batch: The transaction wrapped in a batch
"""
agent_address = addresser.get_agent_address(
transaction_signer.get_public_key().as_hex())
record_address = addresser.get_record_address(record_id)
inputs = [agent_address, record_address]
outputs = [record_address]
action = payload_pb2.UpdateRecordAction(record_id=record_id,
seq=seq,
ts=ts,
device=device,
ddata=ddata,
dsize=dsize,
dhash=dhash,
timestamp=timestamp)
payload = payload_pb2.SimpleSupplyPayload(
action=payload_pb2.SimpleSupplyPayload.UPDATE_RECORD,
update_record=action,
timestamp=timestamp)
payload_bytes = payload.SerializeToString()
return _make_batch(payload_bytes=payload_bytes,
inputs=inputs,
outputs=outputs,
transaction_signer=transaction_signer,
batch_signer=batch_signer)
def get_agent(self, public_key):
"""Gets the agent associated with the public_key
Args:
public_key (str): The public key of the agent
Returns:
agent_pb2.Agent: Agent with the provided public_key
"""
address = addresser.get_agent_address(public_key)
state_entries = self._context.get_state(
addresses=[address], timeout=self._timeout)
if state_entries:
container = agent_pb2.AgentContainer()
container.ParseFromString(state_entries[0].data)
for agent in container.entries:
if agent.public_key == public_key:
return agent
return None
