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)