def _handle_search(self, oef_search_msg: OefSearchMessage,
oef_search_dialogue: OefSearchDialogue) -> None:
"""
Handle the search response.
:param agents: the agents returned by the search
:return: None
"""
if len(oef_search_msg.agents) == 0:
self.context.logger.info(
"[{}]: found no agents, continue searching.".format(
self.context.agent_name))
return
self.context.logger.info(
"[{}]: found agents={}, stopping search.".format(
self.context.agent_name,
list(map(lambda x: x[-5:], oef_search_msg.agents)),
))
strategy = cast(Strategy, self.context.strategy)
strategy.is_searching = False
query = strategy.get_service_query()
fipa_dialogues = cast(FipaDialogues, self.context.fipa_dialogues)
for opponent_address in oef_search_msg.agents:
cfp_msg = FipaMessage(
dialogue_reference=fipa_dialogues.
new_self_initiated_dialogue_reference(),
performative=FipaMessage.Performative.CFP,
query=query,
)
cfp_msg.counterparty = opponent_address
fipa_dialogues.update(cfp_msg)
self.context.logger.info("[{}]: sending CFP to agent={}".format(
self.context.agent_name, opponent_address[-5:]))
self.context.outbox.put_message(message=cfp_msg)
def test_end_serialization():
"""Test the serialization-deserialization of the end performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.END,
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert (expected_envelope.protocol_specification_id ==
actual_envelope.protocol_specification_id)
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_performative_match_accept():
"""Test the serialization - deserialization of the match_accept performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.MATCH_ACCEPT,
)
msg.counterparty = "receiver"
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg,
)
msg.counterparty = "receiver"
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.counterparty = actual_envelope.to
expected_msg = msg
assert expected_msg == actual_msg
def _handle_signed_message(self, signing_msg: SigningMessage,
signing_dialogue: SigningDialogue) -> None:
"""
Handle a signed message.
:param signing_msg: the signing message
:param signing_dialogue: the dialogue
:return: None
"""
fipa_dialogue = (signing_dialogue.associated_contract_api_dialogue.
associated_fipa_dialogue)
last_fipa_msg = fipa_dialogue.last_incoming_message
assert last_fipa_msg is not None, "Could not retrieve last fipa message."
inform_msg = FipaMessage(
message_id=last_fipa_msg.message_id + 1,
dialogue_reference=fipa_dialogue.dialogue_label.dialogue_reference,
target=last_fipa_msg.message_id,
performative=FipaMessage.Performative.ACCEPT_W_INFORM,
info={"tx_signature": signing_msg.signed_message.body},
)
inform_msg.counterparty = last_fipa_msg.counterparty
self.context.logger.info(
"[{}]: sending ACCEPT_W_INFORM to agent={}: tx_signature={}".
format(
self.context.agent_name,
last_fipa_msg.counterparty[-5:],
signing_msg.signed_message,
))
self.context.outbox.put_message(message=inform_msg)
def _handle_match_accept(self, msg: FipaMessage,
dialogue: Dialogue) -> None:
"""
Handle the match accept.
:param msg: the message
:param dialogue: the dialogue object
:return: None
"""
strategy = cast(Strategy, self.context.strategy)
if strategy.is_ledger_tx:
self.context.logger.info(
"[{}]: received MATCH_ACCEPT_W_INFORM from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
info = msg.info
address = cast(str, info.get("address"))
proposal = cast(Description, dialogue.proposal)
tx_msg = TransactionMessage(
performative=TransactionMessage.Performative.
PROPOSE_FOR_SETTLEMENT,
skill_callback_ids=[self.context.skill_id],
tx_id="transaction0",
tx_sender_addr=self.context.agent_addresses[
proposal.values["ledger_id"]],
tx_counterparty_addr=address,
tx_amount_by_currency_id={
proposal.values["currency_id"]: -proposal.values["price"]
},
tx_sender_fee=strategy.max_buyer_tx_fee,
tx_counterparty_fee=proposal.values["seller_tx_fee"],
tx_quantities_by_good_id={},
ledger_id=proposal.values["ledger_id"],
info={"dialogue_label": dialogue.dialogue_label.json},
tx_nonce=proposal.values["tx_nonce"],
)
self.context.decision_maker_message_queue.put_nowait(tx_msg)
self.context.logger.info(
"[{}]: proposing the transaction to the decision maker. Waiting for confirmation ..."
.format(self.context.agent_name))
else:
new_message_id = msg.message_id + 1
new_target = msg.message_id
inform_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target,
performative=FipaMessage.Performative.INFORM,
info={"Done": "Sending payment via bank transfer"},
)
inform_msg.counterparty = msg.counterparty
dialogue.update(inform_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(inform_msg),
)
self.context.logger.info(
"[{}]: informing counterparty={} of payment.".format(
self.context.agent_name, msg.counterparty[-5:]))
def test_cfp_serialization():
"""Test that the serialization for the 'fipa' protocol works."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.CFP,
query=Query([Constraint("something", ConstraintType(">", 1))]),
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_positive_message_has_attributes_valid_type(self):
"""Test the message_has_attributes method where the message is of the specified type."""
dummy_message = FipaMessage(
dialogue_reference=("0", "0"),
message_id=1,
performative=FipaMessage.Performative.CFP,
target=0,
query="some_query",
)
dummy_message.to = "some_to"
dummy_message.sender = "some_sender"
valid_has_attribute, valid_has_attribute_msg = self.message_has_attributes(
actual_message=dummy_message,
message_type=FipaMessage,
message_id=1,
performative=FipaMessage.Performative.CFP,
target=0,
query="some_query",
to="some_to",
sender="some_sender",
)
assert valid_has_attribute
assert (valid_has_attribute_msg ==
"The message has the provided expected attributes.")
def test_match_accept_with_inform_serialization():
"""Test the serialization - deserialization of the match_accept_with_address performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,
info={
"address": "dummy_address",
"signature": "my_signature"
},
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_inform_serialization():
"""Test the serialization-deserialization of the inform performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.INFORM,
info={"foo": "bar"},
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_error_unsupported_skill(self):
"""Test the unsupported skill."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.counterparty = self.address
msg.sender = self.address
envelope = Envelope(
to=msg.counterparty,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
self.my_error_handler.send_unsupported_skill(envelope=envelope)
wait_for_condition(lambda: len(self.my_aea._inbox._history) >= 1,
timeout=5)
envelope = self.my_aea._inbox._history[-1]
msg = envelope.message
assert msg.performative == DefaultMessage.Performative.ERROR
assert msg.error_code == DefaultMessage.ErrorCode.UNSUPPORTED_SKILL
def test_negative_message_has_attributes_invalid_message_id(self):
"""Negative test for message_has_attributes method where the message id does NOT match."""
dummy_message = FipaMessage(
dialogue_reference=("0", "0"),
message_id=1,
performative=FipaMessage.Performative.CFP,
target=0,
query="some_query",
)
dummy_message.to = "some_to"
dummy_message.sender = "some_sender"
invalid_has_attribute, invalid_has_attribute_msg = self.message_has_attributes(
actual_message=dummy_message,
message_type=FipaMessage,
message_id=2,
performative=FipaMessage.Performative.CFP,
target=0,
query="some_query",
to="some_to",
sender="some_sender",
)
assert not invalid_has_attribute
assert (
invalid_has_attribute_msg ==
"The 'message_id' fields do not match. Actual 'message_id': 1. Expected 'message_id': 2"
)
def test_error_decoding_error(self):
"""Test the decoding error."""
self.my_aea._inbox._history = []
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.counterparty = self.address
envelope = Envelope(
to=self.address,
sender=self.address,
protocol_id=DefaultMessage.protocol_id,
message=msg,
)
self.my_error_handler.send_decoding_error(envelope)
wait_for_condition(lambda: len(self.my_aea._inbox._history) >= 1,
timeout=5)
envelope = self.my_aea._inbox._history[-1]
msg = envelope.message
assert msg.performative == DefaultMessage.Performative.ERROR
assert msg.error_code == DefaultMessage.ErrorCode.DECODING_ERROR
def _handle_search(self, oef_search_msg: OefSearchMessage,
oef_search_dialogue: OefSearchDialogue) -> None:
"""
Handle the search response.
:param agents: the agents returned by the search
:return: None
"""
if len(oef_search_msg.agents) == 0:
self.context.logger.info("found no agents, continue searching.")
return
self.context.logger.info("found agents={}, stopping search.".format(
list(map(lambda x: x[-5:], oef_search_msg.agents)), ))
strategy = cast(GenericStrategy, self.context.strategy)
strategy.is_searching = False # stopping search
query = strategy.get_service_query()
fipa_dialogues = cast(FipaDialogues, self.context.fipa_dialogues)
for idx, counterparty in enumerate(oef_search_msg.agents):
if idx >= strategy.max_negotiations:
continue
cfp_msg = FipaMessage(
performative=FipaMessage.Performative.CFP,
dialogue_reference=fipa_dialogues.
new_self_initiated_dialogue_reference(),
query=query,
)
cfp_msg.counterparty = counterparty
fipa_dialogues.update(cfp_msg)
self.context.outbox.put_message(message=cfp_msg)
self.context.logger.info("sending CFP to agent={}".format(
counterparty[-5:]))
def _handle_accept(self, fipa_msg: FipaMessage,
fipa_dialogue: FipaDialogue) -> None:
"""
Handle the ACCEPT.
Respond with a MATCH_ACCEPT_W_INFORM which contains the address to send the funds to.
:param fipa_msg: the message
:param fipa_dialogue: the dialogue object
:return: None
"""
self.context.logger.info("[{}]: received ACCEPT from sender={}".format(
self.context.agent_name, fipa_msg.counterparty[-5:]))
match_accept_msg = FipaMessage(
performative=FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,
message_id=fipa_msg.message_id + 1,
dialogue_reference=fipa_dialogue.dialogue_label.dialogue_reference,
target=fipa_msg.message_id,
info={"address": fipa_dialogue.terms.sender_address},
)
self.context.logger.info(
"[{}]: sending MATCH_ACCEPT_W_INFORM to sender={} with info={}".
format(
self.context.agent_name,
fipa_msg.counterparty[-5:],
match_accept_msg.info,
))
match_accept_msg.counterparty = fipa_msg.counterparty
fipa_dialogue.update(match_accept_msg)
self.context.outbox.put_message(message=match_accept_msg)
def _handle_transaction_digest(
self, ledger_api_msg: LedgerApiMessage,
ledger_api_dialogue: LedgerApiDialogue) -> None:
"""
Handle a message of transaction_digest performative.
:param ledger_api_message: the ledger api message
:param ledger_api_dialogue: the ledger api dialogue
"""
fipa_dialogue = ledger_api_dialogue.associated_fipa_dialogue
self.context.logger.info(
"transaction was successfully submitted. Transaction digest={}".
format(ledger_api_msg.transaction_digest))
fipa_msg = cast(Optional[FipaMessage],
fipa_dialogue.last_incoming_message)
assert fipa_msg is not None, "Could not retrieve fipa message"
inform_msg = FipaMessage(
performative=FipaMessage.Performative.INFORM,
message_id=fipa_msg.message_id + 1,
dialogue_reference=fipa_dialogue.dialogue_label.dialogue_reference,
target=fipa_msg.message_id,
info={
"transaction_digest": ledger_api_msg.transaction_digest.body
},
)
inform_msg.counterparty = fipa_dialogue.dialogue_label.dialogue_opponent_addr
fipa_dialogue.update(inform_msg)
self.context.outbox.put_message(message=inform_msg)
self.context.logger.info(
"informing counterparty={} of transaction digest.".format(
fipa_dialogue.dialogue_label.dialogue_opponent_addr[-5:], ))
def _handle_accept(self, msg: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle the ACCEPT.
Respond with a MATCH_ACCEPT_W_INFORM which contains the address to send the funds to.
:param msg: the message
:param dialogue: the dialogue object
:return: None
"""
new_message_id = msg.message_id + 1
new_target = msg.message_id
self.context.logger.info("[{}]: received ACCEPT from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
self.context.logger.info(
"[{}]: sending MATCH_ACCEPT_W_INFORM to sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
proposal = cast(Description, dialogue.proposal)
identifier = cast(str, proposal.values.get("ledger_id"))
match_accept_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target,
performative=FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,
info={"address": self.context.agent_addresses[identifier]},
)
match_accept_msg.counterparty = msg.counterparty
dialogue.update(match_accept_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(match_accept_msg),
)
def test_propose_serialization():
"""Test that the serialization for the 'fipa' protocol works."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.PROPOSE,
proposal=Description({
"foo1": 1,
"bar1": 2
}),
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = FipaMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_fipa_cfp_serialization_bytes():
"""Test that the serialization - deserialization for the 'fipa' protocol works."""
query = Query([Constraint("something", ConstraintType(">", 1))])
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.CFP,
query=query,
)
msg.counterparty = "sender"
msg_bytes = FipaSerializer().encode(msg)
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg_bytes,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope == actual_envelope
actual_msg = FipaSerializer().decode(actual_envelope.message)
actual_msg.counterparty = "sender"
expected_msg = msg
assert expected_msg == actual_msg
deserialised_msg = FipaSerializer().decode(envelope.message)
deserialised_msg.counterparty = "sender"
assert msg.get("performative") == deserialised_msg.get("performative")
def test_performative_match_accept_with_inform():
"""Test the serialization - deserialization of the match_accept_with_address performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,
info={
"address": "dummy_address",
"signature": "my_signature"
},
)
msg_bytes = FipaSerializer().encode(msg)
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg_bytes,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope == actual_envelope
deserialised_msg = FipaSerializer().decode(envelope.message)
assert msg.get("performative") == deserialised_msg.get("performative")
def test_fipa_accept_serialization():
"""Test that the serialization for the 'fipa' protocol works."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.counterparty = "sender"
msg_bytes = FipaSerializer().encode(msg)
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg_bytes,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope == actual_envelope
actual_msg = FipaSerializer().decode(actual_envelope.message)
actual_msg.counterparty = "sender"
expected_msg = msg
assert expected_msg == actual_msg
def _on_propose(self, propose: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle a Propose.
:param propose: the message containing the Propose
:param dialogue: the dialogue
:return: None
"""
new_msg_id = propose.message_id + 1
strategy = cast(Strategy, self.context.strategy)
proposal_description = propose.proposal
self.context.logger.debug("[{}]: on Propose as {}.".format(
self.context.agent_name, dialogue.role))
transactions = cast(Transactions, self.context.transactions)
transaction_msg = transactions.generate_transaction_message(
TransactionMessage.Performative.PROPOSE_FOR_SIGNING,
proposal_description,
dialogue.dialogue_label,
cast(Dialogue.AgentRole, dialogue.role),
self.context.agent_address,
)
if strategy.is_profitable_transaction(transaction_msg,
role=cast(
Dialogue.AgentRole,
dialogue.role)):
self.context.logger.info("[{}]: Accepting propose (as {}).".format(
self.context.agent_name, dialogue.role))
transactions.add_locked_tx(transaction_msg,
role=cast(Dialogue.AgentRole,
dialogue.role))
transactions.add_pending_initial_acceptance(
dialogue.dialogue_label, new_msg_id, transaction_msg)
fipa_msg = FipaMessage(
performative=FipaMessage.Performative.ACCEPT,
message_id=new_msg_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=propose.message_id,
)
else:
self.context.logger.info("[{}]: Declining propose (as {})".format(
self.context.agent_name, dialogue.role))
fipa_msg = FipaMessage(
performative=FipaMessage.Performative.DECLINE,
message_id=new_msg_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=propose.message_id,
)
dialogues = cast(Dialogues, self.context.dialogues)
dialogues.dialogue_stats.add_dialogue_endstate(
Dialogue.EndState.DECLINED_PROPOSE, dialogue.is_self_initiated)
fipa_msg.counterparty = propose.counterparty
dialogue.update(fipa_msg)
self.context.outbox.put_message(
to=dialogue.dialogue_label.dialogue_opponent_addr,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(fipa_msg),
)
def decode(obj: bytes) -> Message:
"""
Decode bytes into a 'Fipa' message.
:param obj: the bytes object.
:return: the 'Fipa' message.
"""
message_pb = ProtobufMessage()
fipa_pb = fipa_pb2.FipaMessage()
message_pb.ParseFromString(obj)
message_id = message_pb.dialogue_message.message_id
dialogue_reference = (
message_pb.dialogue_message.dialogue_starter_reference,
message_pb.dialogue_message.dialogue_responder_reference,
)
target = message_pb.dialogue_message.target
fipa_pb.ParseFromString(message_pb.dialogue_message.content)
performative = fipa_pb.WhichOneof("performative")
performative_id = FipaMessage.Performative(str(performative))
performative_content = dict() # type: Dict[str, Any]
if performative_id == FipaMessage.Performative.CFP:
pb2_query = fipa_pb.cfp.query
query = Query.decode(pb2_query)
performative_content["query"] = query
elif performative_id == FipaMessage.Performative.PROPOSE:
pb2_proposal = fipa_pb.propose.proposal
proposal = Description.decode(pb2_proposal)
performative_content["proposal"] = proposal
elif performative_id == FipaMessage.Performative.ACCEPT_W_INFORM:
info = fipa_pb.accept_w_inform.info
info_dict = dict(info)
performative_content["info"] = info_dict
elif performative_id == FipaMessage.Performative.MATCH_ACCEPT_W_INFORM:
info = fipa_pb.match_accept_w_inform.info
info_dict = dict(info)
performative_content["info"] = info_dict
elif performative_id == FipaMessage.Performative.INFORM:
info = fipa_pb.inform.info
info_dict = dict(info)
performative_content["info"] = info_dict
elif performative_id == FipaMessage.Performative.ACCEPT:
pass
elif performative_id == FipaMessage.Performative.DECLINE:
pass
elif performative_id == FipaMessage.Performative.MATCH_ACCEPT:
pass
elif performative_id == FipaMessage.Performative.END:
pass
else:
raise ValueError("Performative not valid: {}.".format(performative_id))
return FipaMessage(
message_id=message_id,
dialogue_reference=dialogue_reference,
target=target,
performative=performative,
**performative_content
)
def _handle_propose(self, msg: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle the propose.
:param msg: the message
:param dialogue: the dialogue object
:return: None
"""
new_message_id = msg.message_id + 1
new_target_id = msg.message_id
proposal = msg.proposal
self.context.logger.info(
"[{}]: received proposal={} from sender={}".format(
self.context.agent_name, proposal.values, msg.counterparty[-5:]
)
)
strategy = cast(Strategy, self.context.strategy)
acceptable = strategy.is_acceptable_proposal(proposal)
affordable = strategy.is_affordable_proposal(proposal)
if acceptable and affordable:
strategy.is_searching = False
self.context.logger.info(
"[{}]: accepting the proposal from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]
)
)
dialogue.proposal = proposal
accept_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target_id,
performative=FipaMessage.Performative.ACCEPT,
)
dialogue.outgoing_extend(accept_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(accept_msg),
)
else:
self.context.logger.info(
"[{}]: declining the proposal from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]
)
)
decline_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target_id,
performative=FipaMessage.Performative.DECLINE,
)
dialogue.outgoing_extend(decline_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(decline_msg),
)
def _on_propose(self, propose: FipaMessage,
fipa_dialogue: FipaDialogue) -> None:
"""
Handle a Propose.
:param propose: the message containing the Propose
:param fipa_dialogue: the fipa_dialogue
:return: None
"""
new_msg_id = propose.message_id + 1
strategy = cast(Strategy, self.context.strategy)
proposal_description = propose.proposal
self.context.logger.debug("on Propose as {}.".format(
fipa_dialogue.role))
transactions = cast(Transactions, self.context.transactions)
signing_msg = transactions.generate_signing_message(
SigningMessage.Performative.SIGN_MESSAGE,
proposal_description,
fipa_dialogue.dialogue_label,
cast(FipaDialogue.Role, fipa_dialogue.role),
self.context.agent_address,
)
if strategy.is_profitable_transaction(signing_msg,
role=cast(
FipaDialogue.Role,
fipa_dialogue.role)):
self.context.logger.info("accepting propose (as {}).".format(
fipa_dialogue.role))
transactions.add_locked_tx(signing_msg,
role=cast(FipaDialogue.Role,
fipa_dialogue.role))
transactions.add_pending_initial_acceptance(
fipa_dialogue.dialogue_label, new_msg_id, signing_msg)
fipa_msg = FipaMessage(
performative=FipaMessage.Performative.ACCEPT,
message_id=new_msg_id,
dialogue_reference=fipa_dialogue.dialogue_label.
dialogue_reference,
target=propose.message_id,
)
else:
self.context.logger.info("declining propose (as {})".format(
fipa_dialogue.role))
fipa_msg = FipaMessage(
performative=FipaMessage.Performative.DECLINE,
message_id=new_msg_id,
dialogue_reference=fipa_dialogue.dialogue_label.
dialogue_reference,
target=propose.message_id,
)
fipa_dialogues = cast(FipaDialogues, self.context.fipa_dialogues)
fipa_dialogues.dialogue_stats.add_dialogue_endstate(
FipaDialogue.EndState.DECLINED_PROPOSE,
fipa_dialogue.is_self_initiated)
fipa_msg.counterparty = propose.counterparty
fipa_dialogue.update(fipa_msg)
self.context.outbox.put_message(message=fipa_msg)
def _handle_match_accept(
self, fipa_msg: FipaMessage, fipa_dialogue: FipaDialogue
) -> None:
"""
Handle the match accept.
:param fipa_msg: the message
:param fipa_dialogue: the dialogue object
:return: None
"""
self.context.logger.info(
"received MATCH_ACCEPT_W_INFORM from sender={} with info={}".format(
fipa_msg.counterparty[-5:], fipa_msg.info
)
)
strategy = cast(GenericStrategy, self.context.strategy)
if strategy.is_ledger_tx:
transfer_address = fipa_msg.info.get("address", None)
if transfer_address is not None and isinstance(transfer_address, str):
fipa_dialogue.terms.counterparty_address = transfer_address
ledger_api_dialogues = cast(
LedgerApiDialogues, self.context.ledger_api_dialogues
)
ledger_api_msg = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_RAW_TRANSACTION,
dialogue_reference=ledger_api_dialogues.new_self_initiated_dialogue_reference(),
terms=fipa_dialogue.terms,
)
ledger_api_msg.counterparty = LEDGER_API_ADDRESS
ledger_api_dialogue = cast(
Optional[LedgerApiDialogue], ledger_api_dialogues.update(ledger_api_msg)
)
assert (
ledger_api_dialogue is not None
), "Error when creating ledger api dialogue."
ledger_api_dialogue.associated_fipa_dialogue = fipa_dialogue
fipa_dialogue.associated_ledger_api_dialogue = ledger_api_dialogue
self.context.outbox.put_message(message=ledger_api_msg)
self.context.logger.info(
"requesting transfer transaction from ledger api..."
)
else:
inform_msg = FipaMessage(
message_id=fipa_msg.message_id + 1,
dialogue_reference=fipa_dialogue.dialogue_label.dialogue_reference,
target=fipa_msg.message_id,
performative=FipaMessage.Performative.INFORM,
info={"Done": "Sending payment via bank transfer"},
)
inform_msg.counterparty = fipa_msg.counterparty
fipa_dialogue.update(inform_msg)
self.context.outbox.put_message(message=inform_msg)
self.context.logger.info(
"informing counterparty={} of payment.".format(
fipa_msg.counterparty[-5:]
)
)
def _handle_cfp(self, msg: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle the CFP.
If the CFP matches the supplied services then send a PROPOSE, otherwise send a DECLINE.
:param msg: the message
:param dialogue: the dialogue object
:return: None
"""
new_message_id = msg.message_id + 1
new_target = msg.message_id
self.context.logger.info("[{}]: received CFP from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
query = cast(Query, msg.query)
strategy = cast(Strategy, self.context.strategy)
if strategy.is_matching_supply(query):
proposal, data_for_sale = strategy.generate_proposal_and_data(
query, msg.counterparty)
dialogue.data_for_sale = data_for_sale
dialogue.proposal = proposal
self.context.logger.info(
"[{}]: sending sender={} a PROPOSE with proposal={}".format(
self.context.agent_name, msg.counterparty[-5:],
proposal.values))
proposal_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target,
performative=FipaMessage.Performative.PROPOSE,
proposal=proposal,
)
dialogue.outgoing_extend(proposal_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(proposal_msg),
)
else:
self.context.logger.info(
"[{}]: declined the CFP from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
decline_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target,
performative=FipaMessage.Performative.DECLINE,
)
dialogue.outgoing_extend(decline_msg)
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(decline_msg),
)
def test_error_handler_handle(self):
"""Test the handle function."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.counterparty = "a_counterparty"
self.my_error_handler.handle(message=msg)
def _on_accept(self, accept: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle an Accept.
:param accept: the Accept message
:param dialogue: the dialogue
:return: None
"""
self.context.logger.debug(
"[{}]: on_accept: msg_id={}, dialogue_reference={}, origin={}, target={}"
.format(
self.context.agent_name,
accept.message_id,
accept.dialogue_reference,
dialogue.dialogue_label.dialogue_opponent_addr,
accept.target,
))
new_msg_id = accept.message_id + 1
transactions = cast(Transactions, self.context.transactions)
transaction_msg = transactions.pop_pending_proposal(
dialogue.dialogue_label, accept.target)
strategy = cast(Strategy, self.context.strategy)
if strategy.is_profitable_transaction(transaction_msg,
role=cast(
Dialogue.AgentRole,
dialogue.role)):
self.context.logger.info(
"[{}]: locking the current state (as {}).".format(
self.context.agent_name, dialogue.role))
transactions.add_locked_tx(transaction_msg,
role=cast(Dialogue.AgentRole,
dialogue.role))
self.context.decision_maker_message_queue.put(transaction_msg)
else:
self.context.logger.debug(
"[{}]: decline the Accept (as {}).".format(
self.context.agent_name, dialogue.role))
fipa_msg = FipaMessage(
performative=FipaMessage.Performative.DECLINE,
message_id=new_msg_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=accept.message_id,
)
fipa_msg.counterparty = accept.counterparty
dialogue.update(fipa_msg)
dialogues = cast(Dialogues, self.context.dialogues)
dialogues.dialogue_stats.add_dialogue_endstate(
Dialogue.EndState.DECLINED_ACCEPT, dialogue.is_self_initiated)
self.context.outbox.put_message(
to=dialogue.dialogue_label.dialogue_opponent_addr,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(fipa_msg),
)
def _handle_cfp(self, msg: FipaMessage, dialogue: Dialogue) -> None:
"""
Handle the CFP.
If the CFP matches the supplied services then send a PROPOSE, otherwise send a DECLINE.
:param msg: the message
:param dialogue: the dialogue object
:return: None
"""
new_message_id = msg.message_id + 1
new_target = msg.message_id
self.context.logger.info("[{}]: received CFP from sender={}".format(
self.context.agent_name, msg.counterparty[-5:]))
if self.context.behaviours.service_registration.is_items_minted:
# simply send the same proposal, independent of the query
strategy = cast(Strategy, self.context.strategy)
contract = cast(ERC1155Contract, self.context.contracts.erc1155)
trade_nonce = contract.generate_trade_nonce(
self.context.agent_address)
token_id = self.context.behaviours.service_registration.token_ids[
0]
proposal = Description({
"contract_address": contract.instance.address,
"token_id": str(token_id),
"trade_nonce": str(trade_nonce),
"from_supply": str(strategy.from_supply),
"to_supply": str(strategy.to_supply),
"value": str(strategy.value),
})
dialogue.proposal = proposal
proposal_msg = FipaMessage(
message_id=new_message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=new_target,
performative=FipaMessage.Performative.PROPOSE,
proposal=proposal,
)
proposal_msg.counterparty = msg.counterparty
dialogue.update(proposal_msg)
self.context.logger.info(
"[{}]: Sending PROPOSE to agent={}: proposal={}".format(
self.context.agent_name, msg.counterparty[-5:],
proposal.values))
self.context.outbox.put_message(
to=msg.counterparty,
sender=self.context.agent_address,
protocol_id=FipaMessage.protocol_id,
message=FipaSerializer().encode(proposal_msg),
)
else:
self.context.logger.info(
"Contract items not minted yet. Try again later.")
def _handle_transaction_receipt(
self, ledger_api_msg: LedgerApiMessage,
ledger_api_dialogue: LedgerApiDialogue) -> None:
"""
Handle a message of balance performative.
:param ledger_api_message: the ledger api message
:param ledger_api_dialogue: the ledger api dialogue
"""
fipa_dialogue = ledger_api_dialogue.associated_fipa_dialogue
is_settled = LedgerApis.is_transaction_settled(
fipa_dialogue.terms.ledger_id,
ledger_api_msg.transaction_receipt.receipt)
is_valid = LedgerApis.is_transaction_valid(
fipa_dialogue.terms.ledger_id,
ledger_api_msg.transaction_receipt.transaction,
fipa_dialogue.terms.sender_address,
fipa_dialogue.terms.counterparty_address,
fipa_dialogue.terms.nonce,
fipa_dialogue.terms.counterparty_payable_amount,
)
if is_settled and is_valid:
last_message = cast(Optional[FipaMessage],
fipa_dialogue.last_incoming_message)
assert last_message is not None, "Cannot retrieve last fipa message."
inform_msg = FipaMessage(
message_id=last_message.message_id + 1,
dialogue_reference=fipa_dialogue.dialogue_label.
dialogue_reference,
target=last_message.message_id,
performative=FipaMessage.Performative.INFORM,
info=fipa_dialogue.data_for_sale,
)
inform_msg.counterparty = last_message.counterparty
fipa_dialogue.update(inform_msg)
self.context.outbox.put_message(message=inform_msg)
fipa_dialogues = cast(FipaDialogues, self.context.fipa_dialogues)
fipa_dialogues.dialogue_stats.add_dialogue_endstate(
FipaDialogue.EndState.SUCCESSFUL,
fipa_dialogue.is_self_initiated)
self.context.logger.info(
"[{}]: transaction confirmed, sending data={} to buyer={}.".
format(
self.context.agent_name,
fipa_dialogue.data_for_sale,
last_message.counterparty[-5:],
))
else:
self.context.logger.info(
"[{}]: transaction_receipt={} not settled or not valid, aborting"
.format(self.context.agent_name,
ledger_api_msg.transaction_receipt))
