def __init__(self, **kwargs) -> None:
"""
Initialize dialogues.
:return: None
"""
def role_from_first_message( # pylint: disable=unused-argument
message: Message, receiver_address: Address
) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
# The ledger connection maintains the dialogue on behalf of the ledger
return LedgerApiDialogue.Role.LEDGER
BaseLedgerApiDialogues.__init__(
self,
self_address=str(CONNECTION_ID),
role_from_first_message=role_from_first_message,
**kwargs,
)
def __init__(self, **kwargs: Any) -> None:
"""
Initialize dialogues.
:return: None
"""
Model.__init__(self, **kwargs)
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return BaseLedgerApiDialogue.Role.AGENT
BaseLedgerApiDialogues.__init__(
self,
self_address=self.context.agent_address,
role_from_first_message=role_from_first_message,
dialogue_class=LedgerApiDialogue,
)
def __init__(self, **kwargs) -> None:
"""
Initialize dialogues.
:return: None
"""
BaseLedgerApiDialogues.__init__(self, str(CONNECTION_ID))
def __init__(self, **kwargs) -> None:
"""
Initialize dialogues.
:return: None
"""
Model.__init__(self, **kwargs)
BaseLedgerApiDialogues.__init__(self, self.context.agent_address)
async def test_get_balance(ledger_id, address, config,
ledger_apis_connection: Connection):
"""Test get balance."""
import aea # noqa # to load registries
ledger_api_dialogues = LedgerApiDialogues(address)
request = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_BALANCE,
dialogue_reference=ledger_api_dialogues.
new_self_initiated_dialogue_reference(),
ledger_id=ledger_id,
address=address,
)
request.counterparty = str(ledger_apis_connection.connection_id)
ledger_api_dialogue = ledger_api_dialogues.update(request)
assert ledger_api_dialogue is not None
envelope = Envelope(
to=str(ledger_apis_connection.connection_id),
sender=address,
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_msg_orig = cast(LedgerApiMessage, response.message)
response_msg = copy.copy(response_msg_orig)
response_msg.is_incoming = True
response_msg.counterparty = response_msg_orig.sender
response_dialogue = ledger_api_dialogues.update(response_msg)
assert response_dialogue == ledger_api_dialogue
assert response_msg.performative == LedgerApiMessage.Performative.BALANCE
actual_balance_amount = response_msg.balance
expected_balance_amount = make_ledger_api(ledger_id,
**config).get_balance(address)
assert actual_balance_amount == expected_balance_amount
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 = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_RAW_TRANSACTION,
dialogue_reference=ledger_api_dialogues.
new_self_initiated_dialogue_reference(),
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.counterparty = str(ledger_apis_connection.connection_id)
ledger_api_dialogue = ledger_api_dialogues.update(request)
assert ledger_api_dialogue is not None
envelope = Envelope(
to=str(ledger_apis_connection.connection_id),
sender=crypto1.address,
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_msg_orig = cast(LedgerApiMessage, response.message)
response_message = copy.copy(response_msg_orig)
response_message.is_incoming = True
response_message.counterparty = response_msg_orig.sender
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 = LedgerApiMessage(
performative=LedgerApiMessage.Performative.SEND_SIGNED_TRANSACTION,
message_id=response_message.message_id + 1,
target=response_message.message_id,
dialogue_reference=ledger_api_dialogue.dialogue_label.
dialogue_reference,
signed_transaction=SignedTransaction(ETHEREUM, signed_transaction),
)
request.counterparty = str(ledger_apis_connection.connection_id)
ledger_api_dialogue.update(request)
envelope = Envelope(
to=str(ledger_apis_connection.connection_id),
sender=crypto1.address,
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_msg_orig = cast(LedgerApiMessage, response.message)
response_message = copy.copy(response_msg_orig)
response_message.is_incoming = True
response_message.counterparty = response_msg_orig.sender
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 = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT,
dialogue_reference=ledger_api_dialogue.dialogue_label.
dialogue_reference,
message_id=response_message.message_id + 1,
target=response_message.message_id,
transaction_digest=response_message.transaction_digest,
)
request.counterparty = str(ledger_apis_connection.connection_id)
ledger_api_dialogue.update(request)
envelope = Envelope(
to=str(ledger_apis_connection.connection_id),
sender=crypto1.address,
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_msg_orig = cast(LedgerApiMessage, response.message)
response_message = copy.copy(response_msg_orig)
response_message.is_incoming = True
response_message.counterparty = response_msg_orig.sender
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."
