def _handle_transaction_receipt( self, ledger_api_msg: LedgerApiMessage, ledger_api_dialogue: LedgerApiDialogue) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}". format(ledger_api_msg.transaction_receipt)) strategy = cast(Strategy, self.context.strategy) contract_api_dialogue = ( ledger_api_dialogue.associated_signing_dialogue. associated_contract_api_dialogue) transaction_label = contract_api_dialogue.terms.kwargs.get( "label", "None") if not strategy.is_contract_deployed and transaction_label == "deploy": contract_address = cast( Optional[str], ledger_api_msg.transaction_receipt.receipt.get( "contractAddress", None), ) if contract_address is None: raise ValueError( "No contract address found.") # pragma: nocover strategy.contract_address = contract_address strategy.is_contract_deployed = is_transaction_successful strategy.is_behaviour_active = is_transaction_successful self.context.logger.info( "Oracle contract successfully deployed!") elif (not strategy.is_oracle_role_granted and transaction_label == "grant_role"): strategy.is_oracle_role_granted = is_transaction_successful if is_transaction_successful: self.context.logger.info( "Oracle role successfully granted!") else: # pragma: nocover self.context.logger.info("Failed to grant oracle role") elif transaction_label == "update": self.context.logger.info("Oracle value successfully updated!") if self.context.prometheus_dialogues.enabled: metric_name = "num_oracle_updates" self.context.behaviours.simple_oracle_behaviour.update_prometheus_metric( metric_name, "inc", 1.0, {}) else: # pragma: nocover self.context.logger.error("unexpected transaction receipt!") else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt))
def _handle_transaction_receipt( self, ledger_api_msg: LedgerApiMessage, ledger_api_dialogue: LedgerApiDialogue) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}". format(ledger_api_msg.transaction_receipt)) strategy = cast(Strategy, self.context.strategy) contract_api_dialogue = ( ledger_api_dialogue.associated_signing_dialogue. associated_contract_api_dialogue) transaction_label = contract_api_dialogue.terms.kwargs.get( "label", "None") if (not strategy.is_client_contract_deployed and transaction_label == "deploy"): client_contract_address = cast( str, ledger_api_msg.transaction_receipt.receipt.get( "contractAddress", None), ) strategy.client_contract_address = client_contract_address strategy.is_client_contract_deployed = is_transaction_successful strategy.is_behaviour_active = is_transaction_successful self.context.logger.info( "Oracle client contract successfully deployed!") elif (not strategy.is_oracle_transaction_approved and transaction_label == "approve"): strategy.is_oracle_transaction_approved = is_transaction_successful if is_transaction_successful: self.context.logger.info( "Oracle client transactions approved!") else: # pragma: nocover self.context.logger.info( "Failed to approve oracle client transactions") elif transaction_label == "query": self.context.logger.info( "Oracle value successfully requested!") else: # pragma nocover self.context.logger.error("unexpected transaction receipt!") else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt))
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))
def _handle_transaction_receipt( self, ledger_api_msg: LedgerApiMessage, ledger_api_dialogue: LedgerApiDialogue ) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ strategy = cast(Strategy, self.context.strategy) is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) contract_reference = ledger_api_dialogue._associated_signing_dialogue._associated_contract_api_dialogue.dialogue_label.dialogue_reference[ 0 ] for contract, status in strategy._deployment_status.items(): if status[0] is None: continue elif status[1] == contract_reference: self.context.logger.info( "retrieved deployment {contract}".format(contract=contract) ) strategy.deployment_status[contract] = ( "deployed", ledger_api_msg.transaction_receipt.receipt["contractAddress"], ) self.context.logger.info( f"** {ledger_api_msg.transaction_receipt.receipt['contractAddress']} Retireved and stored)" ) # if contract in ["ethoptions_create_option", "btcoptions_create_option"]: # strategy.update_option( # strategy.current_order_id, {"status_code_id": 3}) strategy.deployment_status["status"] = "pending" if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}".format( "ledger_api_msg.transaction_receipt" ) ) else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt ) ) raise ValueError("Ledger message failed!")
def _handle_transaction_receipt(self, ledger_api_msg: LedgerApiMessage) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}".format( ledger_api_msg.transaction_receipt ) ) strategy = cast(Strategy, self.context.strategy) if not strategy.is_contract_deployed: contract_address = cast( Optional[str], ledger_api_msg.transaction_receipt.receipt.get( "contractAddress", None ), ) if contract_address is None: raise ValueError("No contract address found.") # pragma: nocover strategy.contract_address = contract_address strategy.is_contract_deployed = is_transaction_successful strategy.is_behaviour_active = is_transaction_successful elif not strategy.is_tokens_created: strategy.is_tokens_created = is_transaction_successful strategy.is_behaviour_active = is_transaction_successful elif not strategy.is_tokens_minted: strategy.is_tokens_minted = is_transaction_successful strategy.is_behaviour_active = is_transaction_successful elif strategy.is_tokens_minted: self.context.is_active = False self.context.logger.info("demo finished!") else: self.context.logger.error("unexpected transaction receipt!") else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt ) )
def _handle_transaction_receipt( self, ledger_api_msg: LedgerApiMessage, ledger_api_dialogue: LedgerApiDialogue) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message :param ledger_api_dialogue: the ledger api dialogue """ is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) signing_dialogue = ledger_api_dialogue.associated_signing_dialogue contract_api_dialogue = signing_dialogue.associated_contract_api_dialogue if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}". format(ledger_api_msg.transaction_receipt)) parameters = cast(Parameters, self.context.parameters) game = cast(Game, self.context.game) if (contract_api_dialogue.callable == ContractApiDialogue.Callable.GET_DEPLOY_TRANSACTION): contract_address = ledger_api_msg.transaction_receipt.receipt.get( "contractAddress", None) parameters.contract_address = contract_address game.phase = Phase.CONTRACT_DEPLOYED self.context.logger.info("contract deployed.") elif (contract_api_dialogue.callable == ContractApiDialogue.Callable.GET_CREATE_BATCH_TRANSACTION): game.phase = Phase.TOKENS_CREATED self.context.logger.info("tokens created.") elif (contract_api_dialogue.callable == ContractApiDialogue.Callable.GET_MINT_BATCH_TRANSACTION): self.context.logger.info("tokens minted.") parameters.nb_completed_minting += 1 game.is_allowed_to_mint = True if game.registration.nb_agents == parameters.nb_completed_minting: game.phase = Phase.TOKENS_MINTED self.context.logger.info("all tokens minted.") else: self.context.logger.error("unexpected transaction receipt!") else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt))
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) tx_behaviour = cast(GenericTransactionBehaviour, self.context.behaviours.transaction) if is_settled: tx_behaviour.finish_processing(ledger_api_dialogue) ledger_api_msg_ = cast(Optional[LedgerApiMessage], ledger_api_dialogue.last_outgoing_message) if ledger_api_msg_ is None: raise ValueError( # pragma: nocover "Could not retrieve last ledger_api message") fipa_msg = cast(Optional[FipaMessage], fipa_dialogue.last_incoming_message) if fipa_msg is None: raise ValueError("Could not retrieve last fipa message") inform_msg = fipa_dialogue.reply( performative=FipaMessage.Performative.INFORM, target_message=fipa_msg, info={ "transaction_digest": ledger_api_msg_.transaction_digest.body }, ) self.context.outbox.put_message(message=inform_msg) self.context.logger.info( "transaction confirmed, informing counterparty={} of transaction digest." .format( fipa_dialogue.dialogue_label.dialogue_opponent_addr[-5:], )) else: tx_behaviour.failed_processing(ledger_api_dialogue) self.context.logger.info( "transaction_receipt={} not settled or not valid, aborting". format(ledger_api_msg.transaction_receipt))
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 """ ml_trade_dialogue = ledger_api_dialogue.associated_ml_trade_dialogue is_settled = LedgerApis.is_transaction_settled( ml_trade_dialogue.terms.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) tx_behaviour = cast(TransactionBehaviour, self.context.behaviours.transaction) if is_settled: tx_behaviour.finish_processing(ledger_api_dialogue) ledger_api_msg_ = cast(Optional[LedgerApiMessage], ledger_api_dialogue.last_outgoing_message) if ledger_api_msg_ is None: raise ValueError( # pragma: nocover "Could not retrieve last ledger_api message") ml_trade_msg = cast(Optional[MlTradeMessage], ml_trade_dialogue.last_incoming_message) if ml_trade_msg is None: raise ValueError("Could not retrieve last ml_trade message") ml_accept = ml_trade_dialogue.reply( performative=MlTradeMessage.Performative.ACCEPT, target_message=ml_trade_msg, tx_digest=ledger_api_msg_.transaction_digest.body, terms=ml_trade_msg.terms, ) self.context.outbox.put_message(message=ml_accept) self.context.logger.info( "informing counterparty={} of transaction digest={}.".format( ml_trade_msg.sender[-5:], ledger_api_msg_.transaction_digest, )) else: tx_behaviour.failed_processing(ledger_api_dialogue) self.context.logger.info( "transaction_receipt={} not settled or not valid, aborting". format(ledger_api_msg.transaction_receipt))
def _handle_transaction_receipt(self, ledger_api_msg: LedgerApiMessage) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) if is_transaction_successful: self.context.logger.info( "transaction was successfully settled. Transaction receipt={}". format(ledger_api_msg.transaction_receipt)) else: self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt))
def wait_tx_settled(identifier: str, tx_digest: str, timeout: float = DEFAULT_SETTLE_TIMEOUT) -> None: """ Wait transaction is settled succesfuly. :param identifier: str, ledger id :param tx_digest: str, transaction digest :param timeout: int, timeout in seconds efore timeout error raised :return: None raises TimeoutError on timeout """ t = time.time() while True: if time.time() - t > timeout: raise TimeoutError() if LedgerApis.is_transaction_settled(identifier, tx_digest): return time.sleep(1)
async def test_send_signed_transaction_ethereum( ledger_apis_connection: Connection): """Test send signed transaction with Ethereum APIs.""" import aea # noqa # to load registries crypto1 = make_crypto(ETHEREUM, private_key_path=ETHEREUM_PRIVATE_KEY_PATH) crypto2 = make_crypto(ETHEREUM) ledger_api_dialogues = LedgerApiDialogues(crypto1.address) amount = 40000 fee = 30000 request, ledger_api_dialogue = ledger_api_dialogues.create( counterparty=str(ledger_apis_connection.connection_id), performative=LedgerApiMessage.Performative.GET_RAW_TRANSACTION, terms=Terms( ledger_id=ETHEREUM, sender_address=crypto1.address, counterparty_address=crypto2.address, amount_by_currency_id={"ETH": -amount}, quantities_by_good_id={"some_service_id": 1}, is_sender_payable_tx_fee=True, nonce="", fee_by_currency_id={"ETH": fee}, chain_id=3, ), ) request = cast(LedgerApiMessage, request) envelope = Envelope( to=request.to, sender=request.sender, protocol_id=request.protocol_id, message=request, ) await ledger_apis_connection.send(envelope) await asyncio.sleep(0.01) response = await ledger_apis_connection.receive() assert response is not None assert type(response.message) == LedgerApiMessage response_message = cast(LedgerApiMessage, response.message) assert (response_message.performative == LedgerApiMessage.Performative.RAW_TRANSACTION) response_dialogue = ledger_api_dialogues.update(response_message) assert response_dialogue == ledger_api_dialogue assert type(response_message.raw_transaction) == RawTransaction assert response_message.raw_transaction.ledger_id == request.terms.ledger_id signed_transaction = crypto1.sign_transaction( response_message.raw_transaction.body) request = cast( LedgerApiMessage, ledger_api_dialogue.reply( performative=LedgerApiMessage.Performative.SEND_SIGNED_TRANSACTION, target_message=response_message, signed_transaction=SignedTransaction(ETHEREUM, signed_transaction), ), ) envelope = Envelope( to=request.to, sender=request.sender, protocol_id=request.protocol_id, message=request, ) await ledger_apis_connection.send(envelope) await asyncio.sleep(0.01) response = await ledger_apis_connection.receive() assert response is not None assert type(response.message) == LedgerApiMessage response_message = cast(LedgerApiMessage, response.message) assert (response_message.performative != LedgerApiMessage.Performative.ERROR ), f"Received error: {response_message.message}" assert (response_message.performative == LedgerApiMessage.Performative.TRANSACTION_DIGEST) response_dialogue = ledger_api_dialogues.update(response_message) assert response_dialogue == ledger_api_dialogue assert type(response_message.transaction_digest) == TransactionDigest assert type(response_message.transaction_digest.body) == str assert (response_message.transaction_digest.ledger_id == request.signed_transaction.ledger_id) assert type(response_message.transaction_digest.body.startswith("0x")) request = cast( LedgerApiMessage, ledger_api_dialogue.reply( performative=LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT, target_message=response_message, transaction_digest=response_message.transaction_digest, ), ) envelope = Envelope( to=request.to, sender=request.sender, protocol_id=request.protocol_id, message=request, ) await ledger_apis_connection.send(envelope) await asyncio.sleep(0.01) response = await ledger_apis_connection.receive() assert response is not None assert type(response.message) == LedgerApiMessage response_message = cast(LedgerApiMessage, response.message) assert (response_message.performative == LedgerApiMessage.Performative.TRANSACTION_RECEIPT) response_dialogue = ledger_api_dialogues.update(response_message) assert response_dialogue == ledger_api_dialogue assert type(response_message.transaction_receipt) == TransactionReceipt assert response_message.transaction_receipt.receipt is not None assert response_message.transaction_receipt.transaction is not None assert (response_message.transaction_receipt.ledger_id == request.transaction_digest.ledger_id) assert LedgerApis.is_transaction_settled( response_message.transaction_receipt.ledger_id, response_message.transaction_receipt.receipt, ), "Transaction not settled."
def _handle_transaction_receipt( self, ledger_api_msg: LedgerApiMessage, ledger_api_dialogue: LedgerApiDialogue) -> None: """ Handle a message of transaction_receipt performative. :param ledger_api_message: the ledger api message """ strategy = cast(Strategy, self.context.strategy) is_transaction_successful = LedgerApis.is_transaction_settled( ledger_api_msg.transaction_receipt.ledger_id, ledger_api_msg.transaction_receipt.receipt, ) contract_reference = ledger_api_dialogue._associated_signing_dialogue._associated_contract_api_dialogue.dialogue_label.dialogue_reference[ 0] for contract, status in strategy.contract_status.items(): if status[0] is None: continue elif status[1] == contract_reference: self.context.logger.info(f"retrieved deployment {contract}") strategy.contract_status[contract] = ( "deployed", ledger_api_msg.transaction_receipt. receipt["contractAddress"], ) self.context.logger.info( f"** {ledger_api_msg.transaction_receipt.receipt['contractAddress']} Retireved and stored)" ) order = strategy.get_order(strategy.current_order.id) if is_transaction_successful: if order.status_code_id == PLACING: # we have created our order strategy.update_current_order( order, { "status_code_id": OPEN, "tx_hash": ledger_api_msg.transaction_receipt.transaction["hash"]. hex(), }, ) # now we mark for placement elif order.status_code_id == OPEN: # we have excercised strategy.update_current_order( order, { "status_code_id": CLOSED, "tx_hash": ledger_api_msg.transaction_receipt.transaction["hash"]. hex(), }, ) # now we mark for placement self.context.logger.info( "transaction was successfully settled. Transaction receipt={}". format("ledger_api_msg.transaction_receipt")) else: strategy.update_current_order( order, { "status_code_id": FAILED, "tx_hash": ledger_api_msg.transaction_receipt.transaction["hash"].hex( ), }, ) # now we mark for placement self.context.logger.error( "transaction failed. Transaction receipt={}".format( ledger_api_msg.transaction_receipt)) strategy.is_order_behaviour_active = False strategy.is_price_behaviour_active = True