def test_terms_encode_decode():
"""Test encoding and decoding of terms."""
class TermsProtobufObject:
terms_bytes = b""
ledger_id = DEFAULT_LEDGER
sender_addr = "SenderAddress"
counterparty_addr = "CounterpartyAddress"
amount_by_currency_id = {"FET": -10}
quantities_by_good_id = {"good_1": 20}
is_sender_payable_tx_fee = True
nonce = "somestring"
terms = Terms(
ledger_id=ledger_id,
sender_address=sender_addr,
counterparty_address=counterparty_addr,
amount_by_currency_id=amount_by_currency_id,
quantities_by_good_id=quantities_by_good_id,
is_sender_payable_tx_fee=is_sender_payable_tx_fee,
nonce=nonce,
is_strict=True,
)
Terms.encode(TermsProtobufObject, terms)
recovered_terms = Terms.decode(TermsProtobufObject)
assert terms == recovered_terms
def test_init_terms_w_fee():
"""Test the terms object initialization with fee."""
ledger_id = DEFAULT_LEDGER
sender_addr = "SenderAddress"
counterparty_addr = "CounterpartyAddress"
amount_by_currency_id = {"FET": -10}
quantities_by_good_id = {"good_1": 20}
is_sender_payable_tx_fee = True
nonce = "somestring"
fee_by_currency_id = {"FET": 1}
terms = Terms(
ledger_id=ledger_id,
sender_address=sender_addr,
counterparty_address=counterparty_addr,
amount_by_currency_id=amount_by_currency_id,
quantities_by_good_id=quantities_by_good_id,
is_sender_payable_tx_fee=is_sender_payable_tx_fee,
nonce=nonce,
fee_by_currency_id=fee_by_currency_id,
)
new_counterparty_address = "CounterpartyAddressNew"
terms.counterparty_address = new_counterparty_address
assert terms.counterparty_address == new_counterparty_address
assert terms.fee == next(iter(fee_by_currency_id.values()))
assert terms.fee_by_currency_id == fee_by_currency_id
assert terms.counterparty_payable_amount == 0
assert terms.sender_payable_amount == -next(
iter(amount_by_currency_id.values()))
assert terms.sender_payable_amount_incl_fee == -next(
iter(amount_by_currency_id.values())) + next(
iter(fee_by_currency_id.values()))
assert terms.sender_fee == next(iter(fee_by_currency_id.values()))
assert terms.counterparty_fee == 0
def test_fipa_dialogue(self):
"""Test the FipaDialogue class."""
fipa_dialogue = FipaDialogue(
DialogueLabel(
("", ""),
COUNTERPARTY_ADDRESS,
self.skill.skill_context.agent_address,
),
self.skill.skill_context.agent_address,
role=DefaultDialogue.Role.AGENT,
)
# terms
with pytest.raises(AEAEnforceError, match="Terms not set!"):
assert fipa_dialogue.terms
terms = Terms(
"some_ledger_id",
self.skill.skill_context.agent_address,
"counterprty",
{"currency_id": 50},
{"good_id": -10},
"some_nonce",
)
fipa_dialogue.terms = terms
with pytest.raises(AEAEnforceError, match="Terms already set!"):
fipa_dialogue.terms = terms
assert fipa_dialogue.terms == terms
def setup(cls):
"""Setup the test class."""
super().setup()
cls.pending_transaction_timeout = 30
cls.transactions = Transactions(
pending_transaction_timeout=cls.pending_transaction_timeout,
name="transactions",
skill_context=cls._skill.skill_context,
)
cls.nonce = "125"
cls.sender = "some_sender_address"
cls.counterparty = "some_counterparty_address"
cls.ledger_id = "some_ledger_id"
cls.terms = Terms(
ledger_id=cls.ledger_id,
sender_address=cls.sender,
counterparty_address=cls.counterparty,
amount_by_currency_id={"1": 10},
quantities_by_good_id={"2": -5},
is_sender_payable_tx_fee=True,
nonce=cls.nonce,
fee_by_currency_id={"1": 1},
)
cls.dialogue_label = DialogueLabel(
("", ""),
COUNTERPARTY_ADDRESS,
cls._skill.skill_context.agent_address,
)
cls.proposal_id = 5
cls.transaction_id = "some_transaction_id"
async def test_no_raw_tx():
"""Test no raw tx returned."""
dispatcher = LedgerApiRequestDispatcher(ConnectionStatus())
mock_api = Mock()
contract_api_dialogues = ContractApiDialogues()
message = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_RAW_TRANSACTION,
dialogue_reference=contract_api_dialogues.
new_self_initiated_dialogue_reference(),
terms=Terms(
ledger_id=EthereumCrypto.identifier,
sender_address="1111",
counterparty_address="22222",
amount_by_currency_id={"ETH": -1},
quantities_by_good_id={"some_service_id": 1},
is_sender_payable_tx_fee=True,
nonce="",
fee_by_currency_id={"ETH": 10},
chain_id=3,
),
)
message.counterparty = "test"
dialogue = contract_api_dialogues.update(message)
mock_api.get_transfer_transaction.return_value = None
msg = dispatcher.get_raw_transaction(mock_api, message, dialogue)
assert msg.performative == LedgerApiMessage.Performative.ERROR
def terms_from_proposal(self, proposal: Description,
counterparty_address: Address) -> Terms:
"""
Get the terms from a proposal.
:param proposal: the proposal
:return: terms
"""
buyer_address = self.context.agent_addresses[
proposal.values["ledger_id"]]
terms = Terms(
ledger_id=proposal.values["ledger_id"],
sender_address=buyer_address,
counterparty_address=counterparty_address,
amount_by_currency_id={
proposal.values["currency_id"]: -proposal.values["price"]
},
quantities_by_good_id={
proposal.values["service_id"]: proposal.values["quantity"]
},
is_sender_payable_tx_fee=True,
nonce=proposal.values["tx_nonce"],
fee_by_currency_id={
proposal.values["currency_id"]: self._max_tx_fee
},
)
return terms
def test_init_terms():
"""Test the terms object initialization."""
ledger_id = "some_ledger"
sender_addr = "SenderAddress"
counterparty_addr = "CounterpartyAddress"
amount_by_currency_id = {"FET": -10}
quantities_by_good_id = {"good_1": 20}
is_sender_payable_tx_fee = True
nonce = "somestring"
kwargs = {"key": "value"}
terms = Terms(ledger_id=ledger_id,
sender_address=sender_addr,
counterparty_address=counterparty_addr,
amount_by_currency_id=amount_by_currency_id,
quantities_by_good_id=quantities_by_good_id,
is_sender_payable_tx_fee=is_sender_payable_tx_fee,
nonce=nonce,
**kwargs)
assert terms.ledger_id == ledger_id
assert terms.sender_address == sender_addr
assert terms.counterparty_address == counterparty_addr
assert terms.amount_by_currency_id == amount_by_currency_id
assert terms.quantities_by_good_id == quantities_by_good_id
assert terms.is_sender_payable_tx_fee == is_sender_payable_tx_fee
assert terms.nonce == nonce
assert terms.kwargs == kwargs
assert (
str(terms) ==
"Terms: ledger_id=some_ledger, sender_address=SenderAddress, counterparty_address=CounterpartyAddress, amount_by_currency_id={'FET': -10}, quantities_by_good_id={'good_1': 20}, is_sender_payable_tx_fee=True, nonce=somestring, fee_by_currency_id=None, kwargs={'key': 'value'}"
)
assert terms == terms
with pytest.raises(AssertionError):
terms.fee
def test_handle_message_signing_ethereum_deprecated(self):
"""Test message signing for ethereum deprecated."""
message = b"0x11f3f9487724404e3a1fb7252a3226"
signing_dialogues = SigningDialogues(
str(PublicId("author", "a_skill", "0.1.0")))
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_MESSAGE,
dialogue_reference=signing_dialogues.
new_self_initiated_dialogue_reference(),
terms=Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_message=RawMessage(ETHEREUM, message, is_deprecated_mode=True),
)
signing_dialogue = signing_dialogues.create_with_message(
"decision_maker", signing_msg)
assert signing_dialogue is not None
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(
timeout=2)
recovered_dialogue = signing_dialogues.update(signing_msg_response)
assert recovered_dialogue is not None and recovered_dialogue == signing_dialogue
assert (signing_msg_response.performative ==
SigningMessage.Performative.SIGNED_MESSAGE)
assert type(signing_msg_response.signed_message) == SignedMessage
assert signing_msg_response.signed_message.is_deprecated_mode
def setup(self) -> None:
"""
Implement the setup.
:return: None
"""
strategy = cast(Strategy, self.context.strategy)
signing_dialogues = cast(SigningDialogues,
self.context.signing_dialogues)
msg, _ = signing_dialogues.create(
counterparty=self.context.decision_maker_address,
performative=SigningMessage.Performative.SIGN_MESSAGE,
raw_message=RawMessage(strategy.ledger_id,
strategy.ethereum_address.encode("utf-8")),
terms=Terms(
ledger_id=strategy.ledger_id,
sender_address="",
counterparty_address="",
amount_by_currency_id={},
quantities_by_good_id={},
nonce="",
),
)
self.context.logger.info("sending signing_msg to decision maker...")
self.context.decision_maker_message_queue.put_nowait(msg)
def setup(cls):
"""Setup the test class."""
super().setup()
cls.signing_handler = cast(SigningHandler,
cls._skill.skill_context.handlers.signing)
cls.ledger_api_dialogues = cast(
LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues)
cls.signing_dialogues = cast(
SigningDialogues, cls._skill.skill_context.signing_dialogues)
cls.logger = cls.signing_handler.context.logger
cls.terms = Terms(
"some_ledger_id",
cls._skill.skill_context.agent_address,
"counterprty",
{"currency_id": 50},
{"good_id": -10},
"some_nonce",
)
cls.list_of_signing_messages = (DialogueMessage(
SigningMessage.Performative.SIGN_TRANSACTION,
{
"terms":
cls.terms,
"raw_transaction":
SigningMessage.RawTransaction("some_ledger_id",
{"some_key": "some_value"}),
},
), )
def test_handle_message_signing_ethereum(self):
"""Test message signing for ethereum."""
message = b"0x11f3f9487724404e3a1fb7252a322656b90ba0455a2ca5fcdcbe6eeee5f8126d"
signing_dialogues = SigningDialogues("agent4")
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_MESSAGE,
dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(),
skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),),
skill_callback_info={},
terms=Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_message=RawMessage(ETHEREUM, message),
)
signing_msg.counterparty = "decision_maker"
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2)
assert (
signing_msg_response.performative
== SigningMessage.Performative.SIGNED_MESSAGE
)
assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids
assert type(signing_msg_response.signed_message) == SignedMessage
def test_terms_from_proposal_buyer(self):
"""Test the terms_from_proposal method of the Strategy class where is_seller is False."""
proposal = Description({
"2": 5,
"ledger_id": self.ledger_id,
"price": 100,
"currency_id": "FET",
"fee": 1,
"nonce": self.nonce,
})
role = FipaDialogue.Role.BUYER
is_seller = False
expected_terms = Terms(
ledger_id=self.ledger_id,
sender_address=self.sender,
counterparty_address=self.counterparty,
amount_by_currency_id={
proposal.values["currency_id"]: -proposal.values["price"]
},
quantities_by_good_id={"2": 5},
is_sender_payable_tx_fee=not is_seller,
nonce=self.nonce,
fee_by_currency_id={
proposal.values["currency_id"]: proposal.values["fee"]
},
)
actual_terms = self.strategy.terms_from_proposal(
proposal, self.sender, self.counterparty, role)
assert actual_terms == expected_terms
def test_kwargs_from_terms_buyer(self):
"""Test the kwargs_from_terms method of the Strategy class where is_seller is False (no difference with seller)."""
is_seller = False
terms = Terms(
ledger_id=self.ledger_id,
sender_address=self.sender,
counterparty_address=self.counterparty,
amount_by_currency_id={"1": 10},
quantities_by_good_id={"2": -5},
is_sender_payable_tx_fee=not is_seller,
nonce=self.nonce,
fee_by_currency_id={"1": 1},
)
expected_kwargs = {
"from_address": self.sender,
"to_address": self.counterparty,
"token_ids": [1, 2],
"from_supplies": [10, 0],
"to_supplies": [0, 5],
"value": 0,
"trade_nonce": 125,
"signature": self.signature,
}
actual_kwargs = self.strategy.kwargs_from_terms(terms, self.signature)
assert actual_kwargs == expected_kwargs
def test_handle_tx_signing_fetchai(self):
"""Test tx signing for fetchai."""
tx = TokenTxFactory.transfer(
FetchaiAddress("v3sZs7gKKz9xmoTo9yzRkfHkjYuX42MzXaq4eVjGHxrX9qu3U"),
FetchaiAddress("2bzQNV4TTjMAiKZe85EyLUttoFpHHuksRzUUBYB1brt98pMXKK"),
1,
1,
[],
)
signing_dialogues = SigningDialogues("agent1")
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_TRANSACTION,
dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(),
skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),),
skill_callback_info={},
terms=Terms(
ledger_id=FETCHAI,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_transaction=RawTransaction(FETCHAI, tx),
)
signing_msg.counterparty = "decision_maker"
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2)
assert (
signing_msg_response.performative
== SigningMessage.Performative.SIGNED_TRANSACTION
)
assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids
assert type(signing_msg_response.signed_transaction.body) == FetchaiTransaction
def test_handle_tx_signing_unknown(self):
"""Test tx signing for unknown."""
tx = {}
signing_dialogues = SigningDialogues("agent")
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_TRANSACTION,
dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(),
skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),),
skill_callback_info={},
terms=Terms(
ledger_id="unknown",
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_transaction=RawTransaction("unknown", tx),
)
signing_msg.counterparty = "decision_maker"
signing_dialogue = signing_dialogues.update(signing_msg)
assert signing_dialogue is not None
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2)
signing_msg_response.counterparty = signing_msg.counterparty
signing_msg_response.is_incoming = True
recovered_dialogue = signing_dialogues.update(signing_msg_response)
assert recovered_dialogue is not None and recovered_dialogue == signing_dialogue
assert signing_msg_response.performative == SigningMessage.Performative.ERROR
assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids
assert (
signing_msg_response.error_code
== SigningMessage.ErrorCode.UNSUCCESSFUL_TRANSACTION_SIGNING
)
def test_handle_tx_signing_ethereum(self):
"""Test tx signing for ethereum."""
tx = {"gasPrice": 30, "nonce": 1, "gas": 20000}
signing_dialogues = SigningDialogues("agent2")
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_TRANSACTION,
dialogue_reference=signing_dialogues.
new_self_initiated_dialogue_reference(),
skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")), ),
skill_callback_info={},
terms=Terms(
ledger_id="ethereum",
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_transaction=RawTransaction("ethereum", tx),
)
signing_msg.counterparty = "decision_maker"
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(
timeout=2)
assert (signing_msg_response.performative ==
SigningMessage.Performative.SIGNED_TRANSACTION)
assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids
assert (type(signing_msg_response.signed_transaction.body) ==
eth_account.datastructures.AttributeDict)
def test_handle_message_signing_unknown_and_two_dialogues(self):
"""Test message signing for unknown."""
message = b"0x11f3f9487724404e3a1fb7252a322656b90ba0455a2ca5fcdcbe6eeee5f8126d"
signing_dialogues = SigningDialogues("agent")
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_MESSAGE,
dialogue_reference=signing_dialogues.new_self_initiated_dialogue_reference(),
skill_callback_ids=(str(PublicId("author", "a_skill", "0.1.0")),),
skill_callback_info={},
terms=Terms(
ledger_id="unknown",
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_message=RawMessage("unknown", message),
)
signing_msg.counterparty = "decision_maker"
signing_dialogue = signing_dialogues.update(signing_msg)
assert signing_dialogue is not None
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(timeout=2)
signing_msg_response.counterparty = signing_msg.counterparty
signing_msg_response.is_incoming = True
recovered_dialogue = signing_dialogues.update(signing_msg_response)
assert recovered_dialogue is not None and recovered_dialogue == signing_dialogue
assert signing_msg_response.performative == SigningMessage.Performative.ERROR
assert signing_msg_response.skill_callback_ids == signing_msg.skill_callback_ids
assert (
signing_msg_response.error_code
== SigningMessage.ErrorCode.UNSUCCESSFUL_MESSAGE_SIGNING
)
def test_handle_tx_signing_ethereum(self):
"""Test tx signing for ethereum."""
tx = {"gasPrice": 30, "nonce": 1, "gas": 20000}
signing_dialogues = SigningDialogues(
str(PublicId("author", "a_skill", "0.1.0")))
signing_msg = SigningMessage(
performative=SigningMessage.Performative.SIGN_TRANSACTION,
dialogue_reference=signing_dialogues.
new_self_initiated_dialogue_reference(),
terms=Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
),
raw_transaction=RawTransaction(ETHEREUM, tx),
)
signing_dialogue = signing_dialogues.create_with_message(
"decision_maker", signing_msg)
assert signing_dialogue is not None
self.decision_maker.message_in_queue.put_nowait(signing_msg)
signing_msg_response = self.decision_maker.message_out_queue.get(
timeout=2)
recovered_dialogue = signing_dialogues.update(signing_msg_response)
assert recovered_dialogue is not None and recovered_dialogue == signing_dialogue
assert (signing_msg_response.performative ==
SigningMessage.Performative.SIGNED_TRANSACTION)
assert (type(signing_msg_response.signed_transaction.body) ==
eth_account.datastructures.SignedTransaction)
def _handle_terms(self, ml_trade_msg: MlTradeMessage,
ml_trade_dialogue: MlTradeDialogue) -> None:
"""
Handle the terms of the request.
:param ml_trade_msg: the ml trade message
:param ml_trade_dialogue: the dialogue object
:return: None
"""
terms = ml_trade_msg.terms
self.context.logger.info(
"received terms message from {}: terms={}".format(
ml_trade_msg.sender[-5:], terms.values))
strategy = cast(Strategy, self.context.strategy)
acceptable = strategy.is_acceptable_terms(terms)
affordable = strategy.is_affordable_terms(terms)
if not acceptable and affordable:
self.context.logger.info(
"rejecting, terms are not acceptable and/or affordable")
return
if strategy.is_ledger_tx:
# construct a tx for settlement on the ledger
ledger_api_dialogues = cast(LedgerApiDialogues,
self.context.ledger_api_dialogues)
ledger_api_msg, ledger_api_dialogue = ledger_api_dialogues.create(
counterparty=LEDGER_API_ADDRESS,
performative=LedgerApiMessage.Performative.GET_RAW_TRANSACTION,
terms=Terms(
ledger_id=terms.values["ledger_id"],
sender_address=self.context.agent_addresses[
terms.values["ledger_id"]],
counterparty_address=terms.values["address"],
amount_by_currency_id={
terms.values["currency_id"]: -terms.values["price"]
},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"ml_training_data": 1},
nonce=uuid.uuid4().hex,
fee_by_currency_id={terms.values["currency_id"]: 1},
),
)
ledger_api_dialogue = cast(LedgerApiDialogue, ledger_api_dialogue)
ledger_api_dialogue.associated_ml_trade_dialogue = ml_trade_dialogue
self.context.outbox.put_message(message=ledger_api_msg)
self.context.logger.info(
"requesting transfer transaction from ledger api...")
else:
# accept directly with a dummy transaction digest, no settlement
ml_accept = ml_trade_dialogue.reply(
performative=MlTradeMessage.Performative.ACCEPT,
target_message=ml_trade_msg,
tx_digest=DUMMY_DIGEST,
terms=terms,
)
self.context.outbox.put_message(message=ml_accept)
self.context.logger.info("sending dummy transaction digest ...")
def test__handle_transaction_receipt_update(self):
"""Test handling an update transaction receipt"""
# setup
ledger_api_dialogue = self.prepare_skill_dialogue(
self.ledger_api_dialogues, self.list_of_ledger_api_messages[2:3])
contract_api_dialogue = self.prepare_skill_dialogue(
self.contract_api_dialogues,
self.list_of_contract_api_messages[:1])
signing_dialogue = self.prepare_skill_dialogue(
self.signing_dialogues, self.list_of_signing_messages[:1])
terms = Terms(*DEFAULT_TERMS, label="update")
strategy = cast(Strategy,
self.simple_oracle_behaviour.context.strategy)
strategy.is_contract_deployed = True
strategy.is_oracle_role_granted = True
contract_api_dialogue.terms = terms
signing_dialogue.associated_contract_api_dialogue = contract_api_dialogue
ledger_api_dialogue.associated_signing_dialogue = signing_dialogue
receipt = {"status": 1, "contractAddress": "some_contract_address"}
transaction_receipt = TransactionReceipt(LEDGER_ID, receipt,
DEFAULT_TX)
incoming_message = self.build_incoming_message_for_skill_dialogue(
dialogue=ledger_api_dialogue,
performative=LedgerApiMessage.Performative.TRANSACTION_RECEIPT,
transaction_receipt=transaction_receipt,
)
# operation
with patch.object(self.ledger_api_handler.context.logger,
"log") as mock_logger:
self.ledger_api_handler.handle(incoming_message)
# after
mock_logger.assert_any_call(
logging.INFO,
f"transaction was successfully settled. Transaction receipt={transaction_receipt}",
)
mock_logger.assert_any_call(
logging.INFO,
"Oracle value successfully updated!",
)
self.assert_quantity_in_outbox(1)
msg = cast(PrometheusMessage, self.get_message_from_outbox())
has_attributes, error_str = self.message_has_attributes(
actual_message=msg,
message_type=PrometheusMessage,
performative=PrometheusMessage.Performative.UPDATE_METRIC,
callable="inc",
title="num_oracle_updates",
value=1.0,
labels={},
)
assert has_attributes, error_str
def test_get_mint_token_terms(self):
"""Test the get_mint_token_terms of Parameters."""
assert self.parameters.get_mint_token_terms() == Terms(
"some_ledger_id",
self.skill.skill_context.agent_address,
self.skill.skill_context.agent_address,
{},
{},
"",
)
def setup(cls):
"""Setup the test class."""
super().setup()
cls.ledger_api_handler = cast(
GenericLedgerApiHandler,
cls._skill.skill_context.handlers.ledger_api)
cls.strategy = cast(GenericStrategy, cls._skill.skill_context.strategy)
cls.fipa_dialogues = cast(FipaDialogues,
cls._skill.skill_context.fipa_dialogues)
cls.ledger_api_dialogues = cast(
LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues)
cls.terms = Terms(
"some_ledger_id",
cls._skill.skill_context.agent_address,
"counterprty",
{"currency_id": 50},
{"good_id": -10},
"some_nonce",
)
cls.list_of_fipa_messages = (
DialogueMessage(FipaMessage.Performative.CFP,
{"query": "some_query"}, True),
DialogueMessage(FipaMessage.Performative.PROPOSE,
{"proposal": "some_proposal"}),
DialogueMessage(FipaMessage.Performative.ACCEPT),
DialogueMessage(
FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,
{"info": {
"address": "some_term_sender_address"
}},
),
DialogueMessage(
FipaMessage.Performative.INFORM,
{
"info": {
"transaction_digest": "some_transaction_digest_body"
}
},
),
)
cls.transaction_digest = TransactionDigest("some_ledger_id",
"some_body")
cls.transaction_receipt = TransactionReceipt("some_ledger_id",
"some_receipt",
"some_transaction")
cls.list_of_ledger_api_messages = (
DialogueMessage(
LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT,
{"transaction_digest": cls.transaction_digest},
),
DialogueMessage(
LedgerApiMessage.Performative.TRANSACTION_RECEIPT,
{"transaction_receipt": cls.transaction_receipt},
),
)
def test_init_terms():
"""Test the terms object initialization."""
ledger_id = DEFAULT_LEDGER
sender_addr = "SenderAddress"
counterparty_addr = "CounterpartyAddress"
amount_by_currency_id = {"FET": -10}
quantities_by_good_id = {"good_1": 20}
is_sender_payable_tx_fee = True
nonce = "somestring"
kwargs = {"key": "value"}
fee_by_currency_id = {}
terms = Terms(
ledger_id=ledger_id,
sender_address=sender_addr,
counterparty_address=counterparty_addr,
amount_by_currency_id=amount_by_currency_id,
quantities_by_good_id=quantities_by_good_id,
is_sender_payable_tx_fee=is_sender_payable_tx_fee,
nonce=nonce,
**kwargs
)
sender_hash = "9af02c24bdb18b73aad129291dc9eee008f9bcf62f5a6e91b5cb7427f146ca3b"
counterparty_hash = (
"174c1321c0eb4a49bf99d783b56f4fc30d0ee558106454c56d1c0fad295ccc79"
)
assert terms.ledger_id == ledger_id
assert terms.sender_address == sender_addr
assert terms.counterparty_address == counterparty_addr
assert terms.amount_by_currency_id == amount_by_currency_id
assert terms.quantities_by_good_id == quantities_by_good_id
assert terms.is_sender_payable_tx_fee == is_sender_payable_tx_fee
assert terms.nonce == nonce
assert terms.kwargs == kwargs
assert terms.fee_by_currency_id == fee_by_currency_id
assert terms.id == sender_hash
assert terms.sender_hash == sender_hash
assert terms.counterparty_hash == counterparty_hash
assert terms.currency_id == next(iter(amount_by_currency_id.keys()))
assert str(
terms
) == "Terms: ledger_id={}, sender_address={}, counterparty_address={}, amount_by_currency_id={}, quantities_by_good_id={}, is_sender_payable_tx_fee={}, nonce={}, fee_by_currency_id={}, kwargs={}".format(
ledger_id,
sender_addr,
counterparty_addr,
amount_by_currency_id,
quantities_by_good_id,
is_sender_payable_tx_fee,
nonce,
fee_by_currency_id,
kwargs,
)
assert terms == terms
with pytest.raises(AssertionError):
terms.fee
def setup_class(cls):
"""Setup class for test case."""
cls.buyer_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
)
cls.neutral_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": 0},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 0},
nonce="transaction nonce",
)
cls.malformed_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -10},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
)
cls.malformed_terms._amount_by_currency_id = {"FET": 10}
cls.seller_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": 1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": -10},
nonce="transaction nonce",
)
cls.skill_callback_ids = (PublicId("author", "a_skill", "0.1.0"),)
cls.skill_callback_info = {"some_info_key": "some_info_value"}
def test_handle_raw_transaction(self, ):
"""Test the _handle_signed_transaction method of the signing handler."""
# setup
contract_api_dialogue = cast(
ContractApiDialogue,
self.prepare_skill_dialogue(
dialogues=self.contract_api_dialogues,
messages=self.list_of_contract_api_messages[:1],
),
)
contract_api_dialogue.terms = Terms(
"some_ledger_id",
self.skill.skill_context.agent_address,
"counterprty",
{"currency_id": 50},
{"good_id": -10},
"some_nonce",
)
incoming_message = self.build_incoming_message_for_skill_dialogue(
dialogue=contract_api_dialogue,
performative=ContractApiMessage.Performative.RAW_TRANSACTION,
raw_transaction=ContractApiMessage.RawTransaction(
"some_ledger_id", {"some_key": "some_value"}),
)
# operation
with patch.object(self.logger, "log") as mock_logger:
self.contract_api_handler.handle(incoming_message)
# after
mock_logger.assert_any_call(
logging.INFO, f"received raw transaction={incoming_message}")
self.assert_quantity_in_decision_making_queue(1)
message = self.get_message_from_decision_maker_inbox()
has_attributes, error_str = self.message_has_attributes(
actual_message=message,
message_type=SigningMessage,
performative=SigningMessage.Performative.SIGN_TRANSACTION,
to=self.skill.skill_context.decision_maker_address,
sender=str(self.skill.skill_context.skill_id),
terms=contract_api_dialogue.terms,
)
assert has_attributes, error_str
assert (cast(SigningDialogue,
self.signing_dialogues.get_dialogue(message)).
associated_contract_api_dialogue == contract_api_dialogue)
mock_logger.assert_any_call(
logging.INFO,
"proposing the transaction to the decision maker. Waiting for confirmation ...",
)
def setup_class(cls):
"""Setup class for test case."""
cls.ledger_id = COSMOS
cls.terms = Terms(
ledger_id=cls.ledger_id,
sender_address="address1",
counterparty_address="address2",
amount_by_currency_id={"FET": -2},
quantities_by_good_id={"good_id": 10},
is_sender_payable_tx_fee=True,
nonce="transaction nonce",
)
def setup_class(cls):
"""Setup class for test case."""
cls.buyer_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
)
cls.neutral_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": 0},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 0},
nonce="transaction nonce",
)
cls.malformed_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -10},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
)
cls.malformed_terms._amount_by_currency_id = {"FET": 10}
cls.seller_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": 1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": -10},
nonce="transaction nonce",
)
def test_handle_inform_is_ledger_tx_and_with_tx_digest(self):
"""Test the _handle_inform method of the fipa handler where is_ledger_tx is True and info contains transaction_digest."""
# setup
self.strategy._is_ledger_tx = True
tx_digest = "some_transaction_digest_body"
ledger_id = "some_ledger_id"
fipa_dialogue = self.prepare_skill_dialogue(
dialogues=self.fipa_dialogues,
messages=self.list_of_messages[:4],
)
fipa_dialogue.terms = Terms(
ledger_id,
self.skill.skill_context.agent_address,
"counterprty",
{"currency_id": 50},
{"good_id": -10},
"some_nonce",
)
incoming_message = self.build_incoming_message_for_skill_dialogue(
dialogue=fipa_dialogue,
performative=FipaMessage.Performative.INFORM,
info={"transaction_digest": tx_digest},
)
# operation
with patch.object(self.fipa_handler.context.logger,
"log") as mock_logger:
self.fipa_handler.handle(incoming_message)
incoming_message = cast(FipaMessage, incoming_message)
# after
mock_logger.assert_any_call(
logging.INFO,
f"received INFORM from sender={COUNTERPARTY_ADDRESS[-5:]}")
mock_logger.assert_any_call(
logging.INFO,
f"checking whether transaction={incoming_message.info['transaction_digest']} has been received ...",
)
self.assert_quantity_in_outbox(1)
has_attributes, error_str = self.message_has_attributes(
actual_message=self.get_message_from_outbox(),
message_type=LedgerApiMessage,
performative=LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT,
to=LEDGER_API_ADDRESS,
sender=self.skill.skill_context.agent_address,
target=0,
transaction_digest=TransactionDigest(ledger_id, tx_digest),
)
assert has_attributes, error_str
def test_is_affordable_for_uninitialized():
"""Test the initialisation of the ownership_state."""
ownership_state = OwnershipState()
buyer_terms = Terms(
ledger_id=ETHEREUM,
sender_address="pk1",
counterparty_address="pk2",
amount_by_currency_id={"FET": -1},
is_sender_payable_tx_fee=True,
quantities_by_good_id={"good_id": 10},
nonce="transaction nonce",
)
assert ownership_state.is_affordable(
terms=buyer_terms), "Any transaction should be classed as affordable."
def test__handle_transaction_receipt_approve(self):
"""Test handling an approve transaction receipt"""
# setup
ledger_api_dialogue = self.prepare_skill_dialogue(
self.ledger_api_dialogues, self.list_of_ledger_api_messages[2:3])
contract_api_dialogue = self.prepare_skill_dialogue(
self.contract_api_dialogues,
self.list_of_contract_api_messages[:1])
signing_dialogue = self.prepare_skill_dialogue(
self.signing_dialogues, self.list_of_signing_messages[:1])
terms = Terms(*DEFAULT_TERMS, label="approve")
strategy = cast(Strategy,
self.simple_oracle_client_behaviour.context.strategy)
strategy.is_contract_deployed = True
contract_api_dialogue.terms = terms
signing_dialogue.associated_contract_api_dialogue = contract_api_dialogue
ledger_api_dialogue.associated_signing_dialogue = signing_dialogue
receipt = {"status": 1, "contractAddress": "some_contract_address"}
transaction_receipt = TransactionReceipt(LEDGER_ID, receipt,
DEFAULT_TX)
incoming_message = self.build_incoming_message_for_skill_dialogue(
dialogue=ledger_api_dialogue,
performative=LedgerApiMessage.Performative.TRANSACTION_RECEIPT,
transaction_receipt=transaction_receipt,
)
# operation
with patch.object(self.ledger_api_handler.context.logger,
"log") as mock_logger:
self.ledger_api_handler.handle(incoming_message)
# after
mock_logger.assert_any_call(
logging.INFO,
f"transaction was successfully settled. Transaction receipt={transaction_receipt}",
)
mock_logger.assert_any_call(
logging.INFO,
"Oracle client transactions approved!",
)
assert (self.simple_oracle_client_behaviour.context.strategy.
is_oracle_transaction_approved
), "Contract deployment status not set"
self.assert_quantity_in_outbox(0)
