def run():
# Create a private keys
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_1)
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_2)
# Set up the wallets
wallet_1 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE_1})
wallet_2 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE_2})
# Set up the LedgerApis
ledger_apis = LedgerApis({FETCHAI: {"network": "testnet"}}, FETCHAI)
# Generate some wealth
_try_generate_testnet_wealth(FETCHAI, wallet_1.addresses[FETCHAI])
logger.info("Sending amount to {}".format(wallet_2.addresses.get(FETCHAI)))
# Create the transaction and send it to the ledger.
ledger_api = ledger_apis.apis[FETCHAI]
tx_nonce = ledger_api.generate_tx_nonce(
wallet_2.addresses.get(FETCHAI), wallet_1.addresses.get(FETCHAI)
)
tx_digest = ledger_api.send_transaction(
crypto=wallet_1.crypto_objects.get(FETCHAI),
destination_address=wallet_2.addresses.get(FETCHAI),
amount=1,
tx_fee=1,
tx_nonce=tx_nonce,
)
logger.info("Transaction complete.")
logger.info("The transaction digest is {}".format(tx_digest))
def tests_generate_wealth_ethereum(self, mock_logging):
"""Test generate wealth for ethereum."""
address = "my_address"
result = ResponseMock(status_code=500)
with patch.object(requests, "get", return_value=result):
_try_generate_testnet_wealth(identifier=ETHEREUM, address=address)
assert mock_logging.error.called
result.status_code = 200
with pytest.raises(SystemExit):
with patch.object(requests, "get", return_value=result):
_try_generate_testnet_wealth(identifier=ETHEREUM, address=address)
def _try_generate_wealth(ctx, type_, sync):
private_key_paths = {
config_pair[0]: config_pair[1]
for config_pair in ctx.agent_config.private_key_paths.read_all()
}
wallet = Wallet(private_key_paths)
try:
address = wallet.addresses[type_]
testnet = TESTNETS[type_]
click.echo(
"Requesting funds for address {} on test network '{}'".format(
address, testnet))
_try_generate_testnet_wealth(type_, address)
if sync:
_wait_funds_release(ctx.agent_config, wallet, type_)
except (AssertionError, ValueError) as e: # pragma: no cover
logger.error(str(e))
sys.exit(1)
def test__try_generate_testnet_wealth_error_resp(self, *mocks):
"""Test _try_generate_testnet_wealth error_resp."""
_try_generate_testnet_wealth(FETCHAI, "address")
_try_generate_testnet_wealth(ETHEREUM, "address")
def run():
# Create a private key
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_1)
# Instantiate the builder and build the AEA
# By default, the default protocol, error skill and stub connection are added
builder = AEABuilder()
builder.set_name("my_aea")
builder.add_private_key(FETCHAI, FETCHAI_PRIVATE_KEY_FILE_1)
builder.add_ledger_api_config(FETCHAI, {"network": "testnet"})
# Create our AEA
my_aea = builder.build()
# Generate some wealth for the default address
_try_generate_testnet_wealth(FETCHAI, my_aea.identity.address)
# add a simple skill with handler
skill_context = SkillContext(my_aea.context)
skill_config = SkillConfig(name="simple_skill",
author="fetchai",
version="0.1.0")
tx_handler = TransactionHandler(skill_context=skill_context,
name="transaction_handler")
simple_skill = Skill(skill_config,
skill_context,
handlers={tx_handler.name: tx_handler})
my_aea.resources.add_skill(simple_skill)
# create a second identity
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_2)
counterparty_wallet = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE_2})
counterparty_identity = Identity(
name="counterparty_aea",
addresses=counterparty_wallet.addresses,
default_address_key=FETCHAI,
)
# create tx message for decision maker to process
fetchai_ledger_api = my_aea.context.ledger_apis.apis[FETCHAI]
tx_nonce = fetchai_ledger_api.generate_tx_nonce(
my_aea.identity.address, counterparty_identity.address)
tx_msg = TransactionMessage(
performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,
skill_callback_ids=[skill_config.public_id],
tx_id="transaction0",
tx_sender_addr=my_aea.identity.address,
tx_counterparty_addr=counterparty_identity.address,
tx_amount_by_currency_id={"FET": -1},
tx_sender_fee=1,
tx_counterparty_fee=0,
tx_quantities_by_good_id={},
ledger_id=FETCHAI,
info={"some_info_key": "some_info_value"},
tx_nonce=tx_nonce,
)
my_aea.context.decision_maker_message_queue.put_nowait(tx_msg)
# Set the AEA running in a different thread
try:
logger.info("STARTING AEA NOW!")
t = Thread(target=my_aea.start)
t.start()
# Let it run long enough to interact with the weather station
time.sleep(20)
finally:
# Shut down the AEA
logger.info("STOPPING AEA NOW!")
my_aea.stop()
t.join()
def run():
# Create a private keys
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_1)
_create_fetchai_private_key(private_key_file=FETCHAI_PRIVATE_KEY_FILE_2)
# Set up the wallets
wallet_1 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE_1})
wallet_2 = Wallet({FETCHAI: FETCHAI_PRIVATE_KEY_FILE_2})
# Generate some wealth
_try_generate_testnet_wealth(FETCHAI, wallet_1.addresses[FETCHAI])
# Set up the LedgerApis
ledger_apis = LedgerApis({FETCHAI: {"network": "testnet"}}, FETCHAI)
tx_handler = TransactionHandler(skill_context="skill_context",
name="fake_skill")
resources = Resources()
resources.handler_registry.register(
(
PublicId.from_str("fetchai/fake_skill:0.1.0"),
PublicId.from_str("fetchai/internal:0.1.0"),
),
tx_handler,
)
stub_connection = StubConnection(input_file_path=INPUT_FILE,
output_file_path=OUTPUT_FILE)
identity_1 = Identity(
name="my_aea",
address=wallet_1.addresses.get(FETCHAI),
default_address_key=FETCHAI,
)
identity_2 = Identity(
name="my_aea_2",
address=wallet_2.addresses.get(FETCHAI),
default_address_key=FETCHAI,
)
# create the AEA
my_aea = AEA(identity_1, [stub_connection], wallet_1, ledger_apis,
resources)
ledger_api = ledger_apis.apis[FETCHAI]
tx_nonce = ledger_api.generate_tx_nonce(identity_1.addresses.get(FETCHAI),
identity_2.addresses.get(FETCHAI))
tx_msg = TransactionMessage(
performative=TransactionMessage.Performative.PROPOSE_FOR_SETTLEMENT,
skill_callback_ids=[PublicId("fetchai", "fake_skill", "0.1.0")],
tx_id="transaction0",
tx_sender_addr=identity_1.addresses.get(FETCHAI),
tx_counterparty_addr=identity_2.addresses.get(FETCHAI),
tx_amount_by_currency_id={"FET": -1},
tx_sender_fee=1,
tx_counterparty_fee=0,
tx_quantities_by_good_id={},
ledger_id=FETCHAI,
info={"some_info_key": "some_info_value"},
tx_nonce=tx_nonce,
)
my_aea.context.decision_maker_message_queue.put_nowait(tx_msg)
# Set the AEA running in a different thread
try:
logger.info("STARTING AEA NOW!")
t = Thread(target=my_aea.start)
t.start()
# Let it run long enough to interact with the weather station
time.sleep(20)
finally:
# Shut down the AEA
logger.info("STOPPING AEA NOW!")
my_aea.stop()
t.join()