def test_construct_sign_and_submit_transfer_transaction():
"""Test the construction, signing and submitting of a transfer transaction."""
account = EthereumCrypto(private_key_path=ETHEREUM_PRIVATE_KEY_PATH)
ec2 = EthereumCrypto()
ethereum_api = EthereumApi(**ETHEREUM_TESTNET_CONFIG)
amount = 40000
tx_nonce = ethereum_api.generate_tx_nonce(ec2.address, account.address)
transfer_transaction = ethereum_api.get_transfer_transaction(
sender_address=account.address,
destination_address=ec2.address,
amount=amount,
tx_fee=30000,
tx_nonce=tx_nonce,
chain_id=3,
)
assert (isinstance(transfer_transaction, dict)
and len(transfer_transaction)
== 7), "Incorrect transfer_transaction constructed."
signed_transaction = account.sign_transaction(transfer_transaction)
assert (isinstance(signed_transaction,
eth_account.datastructures.AttributeDict)
and len(signed_transaction)
== 5), "Incorrect signed_transaction constructed."
transaction_digest = ethereum_api.send_signed_transaction(
signed_transaction)
assert transaction_digest is not None, "Failed to submit transfer transaction!"
not_settled = True
elapsed_time = 0
while not_settled and elapsed_time < 20:
elapsed_time += 1
time.sleep(2)
transaction_receipt = ethereum_api.get_transaction_receipt(
transaction_digest)
if transaction_receipt is None:
continue
is_settled = ethereum_api.is_transaction_settled(transaction_receipt)
not_settled = not is_settled
assert transaction_receipt is not None, "Failed to retrieve transaction receipt."
assert is_settled, "Failed to verify tx!"
tx = ethereum_api.get_transaction(transaction_digest)
is_valid = ethereum_api.is_transaction_valid(tx, ec2.address,
account.address, tx_nonce,
amount)
assert is_valid, "Failed to settle tx correctly!"
assert tx != transaction_receipt, "Should not be same!"
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 = EthereumCrypto(private_key_path=ETHEREUM_PRIVATE_KEY_PATH)
crypto2 = EthereumCrypto()
api = aea.crypto.registries.make_ledger_api(EthereumCrypto.identifier,
**ETHEREUM_TESTNET_CONFIG)
api = cast(EthereumApi, api)
ledger_api_dialogues = LedgerApiDialogues()
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=EthereumCrypto.identifier,
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_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
# raw_tx = api.get_transfer_transaction(
# sender_address=crypto1.address,
# destination_address=crypto2.address,
# amount=amount,
# tx_fee=fee,
# tx_nonce="",
# chain_id=3,
# )
signed_transaction = crypto1.sign_transaction(
response_message.raw_transaction.body)
request = LedgerApiMessage(
performative=LedgerApiMessage.Performative.SEND_SIGNED_TRANSACTION,
dialogue_reference=ledger_api_dialogue.dialogue_label.
dialogue_reference,
signed_transaction=SignedTransaction(EthereumCrypto.identifier,
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_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 = LedgerApiMessage(
performative=LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT,
dialogue_reference=ledger_api_dialogue.dialogue_label.
dialogue_reference,
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_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)