def get_raw_message(
self,
api: LedgerApi,
message: ContractApiMessage,
dialogue: ContractApiDialogue,
) -> ContractApiMessage:
"""
Send the request 'get_raw_message'.
:param api: the API object.
:param message: the Ledger API message
:param dialogue: the contract API dialogue
:return: None
"""
contract = self.contract_registry.make(message.contract_id)
method_to_call = getattr(contract, message.callable)
try:
rm = method_to_call(api, message.contract_address, **message.kwargs.body)
response = ContractApiMessage(
performative=ContractApiMessage.Performative.RAW_MESSAGE,
message_id=message.message_id + 1,
target=message.message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
raw_message=RawMessage(message.ledger_id, rm),
)
response.counterparty = message.counterparty
dialogue.update(response)
except Exception as e: # pylint: disable=broad-except # pragma: nocover
response = self.get_error_message(e, api, message, dialogue)
return response
async def test_run_async():
"""Test run async error handled."""
# for pydocstyle
def _raise():
raise Exception("Expected")
contract_api_dialogues = ContractApiDialogues()
message = ContractApiMessage(
performative=ContractApiMessage.Performative.GET_RAW_TRANSACTION,
dialogue_reference=contract_api_dialogues.new_self_initiated_dialogue_reference(),
ledger_id=EthereumCrypto.identifier,
contract_id="fetchai/erc1155:0.6.0",
contract_address="test addr",
callable="get_create_batch_transaction",
kwargs=ContractApiMessage.Kwargs(
{
"deployer_address": "test_addr",
"token_ids": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
}
),
)
message.counterparty = "test"
dialogue = contract_api_dialogues.update(message)
api = None
msg = await ContractApiRequestDispatcher(ConnectionStatus()).run_async(
_raise, api, message, dialogue
)
assert msg.performative == ContractApiMessage.Performative.ERROR
def get_error_message(
self,
e: Exception,
api: LedgerApi,
message: Message,
dialogue: BaseDialogue,
) -> ContractApiMessage:
"""
Build an error message.
:param e: the exception.
:param api: the Ledger API.
:param message: the request message.
:return: an error message response.
"""
response = ContractApiMessage(
performative=ContractApiMessage.Performative.ERROR,
message_id=message.message_id + 1,
target=message.message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
code=500,
message=str(e),
data=b"",
)
response.counterparty = message.counterparty
dialogue.update(response)
return response
async def test_erc1155_get_raw_message(erc1155_contract, ledger_apis_connection):
"""Test get state with contract erc1155."""
address = ETHEREUM_ADDRESS_ONE
contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
contract_api_dialogues = ContractApiDialogues()
request = ContractApiMessage(
performative=ContractApiMessage.Performative.GET_RAW_MESSAGE,
dialogue_reference=contract_api_dialogues.new_self_initiated_dialogue_reference(),
ledger_id=EthereumCrypto.identifier,
contract_id="fetchai/erc1155:0.6.0",
contract_address=contract_address,
callable="get_hash_single",
kwargs=ContractApiMessage.Kwargs(
{
"from_address": address,
"to_address": address,
"token_id": 1,
"from_supply": 10,
"to_supply": 0,
"value": 0,
"trade_nonce": 1,
}
),
)
request.counterparty = str(ledger_apis_connection.connection_id)
contract_api_dialogue = contract_api_dialogues.update(request)
assert contract_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) == ContractApiMessage
response_message = cast(ContractApiMessage, response.message)
assert (
response_message.performative == ContractApiMessage.Performative.RAW_MESSAGE
), "Error: {}".format(response_message.message)
response_dialogue = contract_api_dialogues.update(response_message)
assert response_dialogue == contract_api_dialogue
assert type(response_message.raw_message) == RawMessage
assert response_message.raw_message.ledger_id == EthereumCrypto.identifier
assert type(response.message.raw_message.body) == bytes
def build_response(rm: bytes) -> ContractApiMessage:
return ContractApiMessage(
performative=ContractApiMessage.Performative.RAW_MESSAGE,
message_id=message.message_id + 1,
target=message.message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
raw_message=RawMessage(message.ledger_id, rm),
)
def build_response(tx: bytes) -> ContractApiMessage:
return ContractApiMessage(
performative=ContractApiMessage.Performative.RAW_TRANSACTION,
message_id=message.message_id + 1,
target=message.message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
raw_transaction=RawTransaction(message.ledger_id, tx),
)
def build_response(data: bytes) -> ContractApiMessage:
return ContractApiMessage(
performative=ContractApiMessage.Performative.STATE,
message_id=message.message_id + 1,
target=message.message_id,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
state=State(message.ledger_id, data),
)
async def test_erc1155_get_state(erc1155_contract, ledger_apis_connection):
"""Test get state with contract erc1155."""
address = ETHEREUM_ADDRESS_ONE
contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
contract_api_dialogues = ContractApiDialogues()
token_id = 1
request = ContractApiMessage(
performative=ContractApiMessage.Performative.GET_STATE,
dialogue_reference=contract_api_dialogues.
new_self_initiated_dialogue_reference(),
ledger_id=ETHEREUM,
contract_id="fetchai/erc1155:0.6.0",
contract_address=contract_address,
callable="get_balance",
kwargs=ContractApiMessage.Kwargs({
"agent_address": address,
"token_id": token_id
}),
)
request.counterparty = str(ledger_apis_connection.connection_id)
contract_api_dialogue = contract_api_dialogues.update(request)
assert contract_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) == ContractApiMessage
response_message = cast(ContractApiMessage, response.message)
assert (response_message.performative ==
ContractApiMessage.Performative.STATE), "Error: {}".format(
response_message.message)
response_dialogue = contract_api_dialogues.update(response_message)
assert response_dialogue == contract_api_dialogue
assert type(response_message.state) == State
assert response_message.state.ledger_id == ETHEREUM
result = response_message.state.body.get("balance", None)
expected_result = {token_id: 0}
assert result is not None and result == expected_result
async def test_erc1155_get_raw_transaction(erc1155_contract,
ledger_apis_connection):
"""Test get state with contract erc1155."""
address = ETHEREUM_ADDRESS_ONE
contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
contract_api_dialogues = ContractApiDialogues()
request = ContractApiMessage(
performative=ContractApiMessage.Performative.GET_RAW_TRANSACTION,
dialogue_reference=contract_api_dialogues.
new_self_initiated_dialogue_reference(),
ledger_id=ETHEREUM,
contract_id="fetchai/erc1155:0.6.0",
contract_address=contract_address,
callable="get_create_batch_transaction",
kwargs=ContractApiMessage.Kwargs({
"deployer_address":
address,
"token_ids": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}),
)
request.counterparty = str(ledger_apis_connection.connection_id)
contract_api_dialogue = contract_api_dialogues.update(request)
assert contract_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) == ContractApiMessage
response_message = cast(ContractApiMessage, response.message)
assert (response_message.performative == ContractApiMessage.Performative.
RAW_TRANSACTION), "Error: {}".format(response_message.message)
response_dialogue = contract_api_dialogues.update(response_message)
assert response_dialogue == contract_api_dialogue
assert type(response_message.raw_transaction) == RawTransaction
assert response_message.raw_transaction.ledger_id == ETHEREUM
assert len(response.message.raw_transaction.body) == 7
assert len(response.message.raw_transaction.body["data"]) > 0
async def test_erc1155_get_deploy_transaction(erc1155_contract, ledger_apis_connection):
"""Test get state with contract erc1155."""
address = ETHEREUM_ADDRESS_ONE
contract_api_dialogues = ContractApiDialogues()
request = ContractApiMessage(
performative=ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION,
dialogue_reference=contract_api_dialogues.new_self_initiated_dialogue_reference(),
ledger_id=EthereumCrypto.identifier,
contract_id="fetchai/erc1155:0.6.0",
callable="get_deploy_transaction",
kwargs=ContractApiMessage.Kwargs({"deployer_address": address}),
)
request.counterparty = str(ledger_apis_connection.connection_id)
contract_api_dialogue = contract_api_dialogues.update(request)
assert contract_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) == ContractApiMessage
response_message = cast(ContractApiMessage, response.message)
assert (
response_message.performative == ContractApiMessage.Performative.RAW_TRANSACTION
), "Error: {}".format(response_message.message)
response_dialogue = contract_api_dialogues.update(response_message)
assert response_dialogue == contract_api_dialogue
assert type(response_message.raw_transaction) == RawTransaction
assert response_message.raw_transaction.ledger_id == EthereumCrypto.identifier
assert len(response.message.raw_transaction.body) == 6
assert len(response.message.raw_transaction.body["data"]) > 0