def verify_or_create_private_keys(ctx: Context) -> None: """ Verify or create private keys. :param ctx: Context """ path = Path(DEFAULT_AEA_CONFIG_FILE) agent_loader = ConfigLoader("aea-config_schema.json", AgentConfig) fp = path.open(mode="r", encoding="utf-8") aea_conf = agent_loader.load(fp) for identifier, _value in aea_conf.private_key_paths.read_all(): if identifier not in registry.supported_crypto_ids: ValueError("Unsupported identifier in private key paths.") for identifier, private_key_path in IDENTIFIER_TO_KEY_FILES.items(): config_private_key_path = aea_conf.private_key_paths.read(identifier) if config_private_key_path is None: create_private_key(identifier) aea_conf.private_key_paths.update(identifier, private_key_path) else: try: _try_validate_private_key_path(identifier, private_key_path) except FileNotFoundError: # pragma: no cover raise click.ClickException( "File {} for private key {} not found.".format( repr(private_key_path), identifier, ) ) # update aea config path = Path(DEFAULT_AEA_CONFIG_FILE) fp = path.open(mode="w", encoding="utf-8") agent_loader.dump(aea_conf, fp) ctx.agent_config = aea_conf
def setup_class(cls): """Set the test up.""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.private_key_path_1 = os.path.join(cls.t, DEFAULT_PRIVATE_KEY_FILE + "_1") cls.private_key_path_2 = os.path.join(cls.t, DEFAULT_PRIVATE_KEY_FILE + "_2") create_private_key(DEFAULT_LEDGER, cls.private_key_path_1) create_private_key(DEFAULT_LEDGER, cls.private_key_path_2)
def setup_class(cls): """Set the test up.""" cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() shutil.copytree(Path(ROOT_DIR, "packages"), Path(cls.t, "packages")) os.chdir(cls.t) cls.private_key_path_1 = os.path.join(cls.t, DEFAULT_PRIVATE_KEY_FILE + "_1") cls.private_key_path_2 = os.path.join(cls.t, DEFAULT_PRIVATE_KEY_FILE + "_2") create_private_key(DEFAULT_LEDGER, cls.private_key_path_1) create_private_key(DEFAULT_LEDGER, cls.private_key_path_2)
def setup_class(cls): """Set the test up.""" cls.runner = CliRunner() cls.cwd = os.getcwd() cls.t = tempfile.mkdtemp() os.chdir(cls.t) cls.private_key_path_1 = os.path.join(cls.t, FetchAICrypto.identifier + "1") cls.private_key_path_2 = os.path.join(cls.t, FetchAICrypto.identifier + "2") create_private_key("fetchai", cls.private_key_path_1) create_private_key("fetchai", cls.private_key_path_2)
def _generate_private_key(type_: str) -> None: """ Generate private key. :param type_: type. :return: None """ types = list(IDENTIFIER_TO_KEY_FILES.keys()) if type_ == "all" else [type_] for type_ in types: private_key_file = IDENTIFIER_TO_KEY_FILES[type_] if _can_write(private_key_file): create_private_key(type_)
def test_issue_certificates(self, *args): """Test agent alias issue certificates.""" self.manager.start_manager() self.manager.add_project(self.project_public_id, local=True) cert_filename = "cert.txt" cert_path = os.path.join(self.manager.data_dir, self.agent_name, cert_filename) assert not os.path.exists(cert_filename) priv_key_path = os.path.abspath( os.path.join(self.working_dir, "priv_key.txt")) create_private_key("fetchai", priv_key_path) assert os.path.exists(priv_key_path) component_overrides = [{ **StubConnection.connection_id.json, "type": "connection", "cert_requests": [{ "identifier": "acn", "ledger_id": "fetchai", "not_after": "2022-01-01", "not_before": "2021-01-01", "public_key": "fetchai", "save_path": cert_filename, }], }] agent_overrides = { "private_key_paths": { "fetchai": priv_key_path }, "connection_private_key_paths": { "fetchai": priv_key_path }, } self.manager.add_agent( self.project_public_id, self.agent_name, agent_overrides=agent_overrides, component_overrides=component_overrides, ) agent_alias = self.manager.get_agent_alias(self.agent_name) agent_alias.issue_certificates() assert os.path.exists(cert_path)
def _create_private_key(self, ledger: str, replace: bool = False, is_connection: bool = False) -> str: """ Create new key for agent alias in working dir keys dir. If file exists, check `replace` option. """ file_name = (f"{ledger}_connection_private.key" if is_connection else f"{ledger}_private.key") filepath = os.path.join(self._data_dir, file_name) if os.path.exists(filepath) and not replace: return filepath create_private_key(ledger, filepath) return filepath
def run(): # Create a private keys create_private_key(FetchAICrypto.identifier, private_key_file=FETCHAI_PRIVATE_KEY_FILE_1) create_private_key(FetchAICrypto.identifier, private_key_file=FETCHAI_PRIVATE_KEY_FILE_2) # Set up the wallets wallet_1 = Wallet({FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE_1}) wallet_2 = Wallet({FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE_2}) # Set up the LedgerApis ledger_apis = LedgerApis( {FetchAICrypto.identifier: { "network": "testnet" }}, FetchAICrypto.identifier) # Generate some wealth try_generate_testnet_wealth(FetchAICrypto.identifier, wallet_1.addresses[FetchAICrypto.identifier]) logger.info("Sending amount to {}".format( wallet_2.addresses.get(FetchAICrypto.identifier))) # Create the transaction and send it to the ledger. tx_nonce = ledger_apis.generate_tx_nonce( FetchAICrypto.identifier, wallet_2.addresses.get(FetchAICrypto.identifier), wallet_1.addresses.get(FetchAICrypto.identifier), ) transaction = ledger_apis.get_transfer_transaction( identifier=FetchAICrypto.identifier, sender_address=wallet_1.addresses.get(FetchAICrypto.identifier), destination_address=wallet_2.addresses.get(FetchAICrypto.identifier), amount=1, tx_fee=1, tx_nonce=tx_nonce, ) signed_transaction = wallet_1.sign_transaction(FetchAICrypto.identifier, transaction) transaction_digest = ledger_apis.send_signed_transaction( FetchAICrypto.identifier, signed_transaction) logger.info("Transaction complete.") logger.info("The transaction digest is {}".format(transaction_digest))
def generate_key(click_context, type_): """Generate private keys.""" def _can_write(path) -> bool: if Path(path).exists(): value = click.confirm( "The file {} already exists. Do you want to overwrite it?". format(path), default=False, ) return value else: return True types = list(IDENTIFIER_TO_KEY_FILES.keys()) if type_ == "all" else [type_] for type_ in types: private_key_file = IDENTIFIER_TO_KEY_FILES[type_] if _can_write(private_key_file): create_private_key(type_)
def _generate_private_key(type_: str, file: Optional[str] = None) -> None: """ Generate private key. :param type_: type. :param file: path to file. :return: None """ if type_ == "all" and file is not None: raise click.ClickException("Type all cannot be used in combination with file.") types = list(crypto_registry.supported_ids) if type_ == "all" else [type_] for type__ in types: private_key_file = ( PRIVATE_KEY_PATH_SCHEMA.format(type__) if file is None else file ) if _can_write(private_key_file): create_private_key(type__, private_key_file)
def run(): # Create a private keys create_private_key( CosmosCrypto.identifier, private_key_file=COSMOS_PRIVATE_KEY_FILE_1 ) create_private_key( CosmosCrypto.identifier, private_key_file=COSMOS_PRIVATE_KEY_FILE_2 ) # Set up the wallets wallet_1 = Wallet({CosmosCrypto.identifier: COSMOS_PRIVATE_KEY_FILE_1}) wallet_2 = Wallet({CosmosCrypto.identifier: COSMOS_PRIVATE_KEY_FILE_2}) # Generate some wealth try_generate_testnet_wealth( CosmosCrypto.identifier, wallet_1.addresses[CosmosCrypto.identifier] ) logger.info( "Sending amount to {}".format(wallet_2.addresses.get(CosmosCrypto.identifier)) ) # Create the transaction and send it to the ledger. tx_nonce = LedgerApis.generate_tx_nonce( CosmosCrypto.identifier, wallet_2.addresses.get(CosmosCrypto.identifier), wallet_1.addresses.get(CosmosCrypto.identifier), ) transaction = LedgerApis.get_transfer_transaction( identifier=CosmosCrypto.identifier, sender_address=wallet_1.addresses.get(CosmosCrypto.identifier), destination_address=wallet_2.addresses.get(CosmosCrypto.identifier), amount=1, tx_fee=1, tx_nonce=tx_nonce, ) signed_transaction = wallet_1.sign_transaction(CosmosCrypto.identifier, transaction) transaction_digest = LedgerApis.send_signed_transaction( CosmosCrypto.identifier, signed_transaction ) logger.info("Transaction complete.") logger.info("The transaction digest is {}".format(transaction_digest))
def _generate_private_key(type_: str, file: Optional[str] = None) -> None: """ Generate private key. :param type_: type. :param file: path to file. :return: None """ if type_ == "all" and file is not None: raise click.ClickException( "Type all cannot be used in combination with file.") elif type_ == "all": types = list(IDENTIFIER_TO_KEY_FILES.keys()) else: types = [type_] for type_ in types: private_key_file = IDENTIFIER_TO_KEY_FILES[ type_] if file is None else file if _can_write(private_key_file): create_private_key(type_, private_key_file)
def run(): # Create a private key create_private_key(CosmosCrypto.identifier, private_key_file=COSMOS_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(CosmosCrypto.identifier, COSMOS_PRIVATE_KEY_FILE_1) # Create our AEA my_aea = builder.build() # add a simple skill with handler skill_context = SkillContext(my_aea.context) skill_config = SkillConfig(name="simple_skill", author="fetchai", version="0.1.0") signing_handler = SigningHandler(skill_context=skill_context, name="signing_handler") signing_dialogues_model = SigningDialogues(skill_context=skill_context, name="signing_dialogues") simple_skill = Skill( skill_config, skill_context, handlers={signing_handler.name: signing_handler}, models={signing_dialogues_model.name: signing_dialogues_model}, ) my_aea.resources.add_skill(simple_skill) # create a second identity create_private_key(CosmosCrypto.identifier, private_key_file=COSMOS_PRIVATE_KEY_FILE_2) counterparty_wallet = Wallet( {CosmosCrypto.identifier: COSMOS_PRIVATE_KEY_FILE_2}) counterparty_identity = Identity( name="counterparty_aea", addresses=counterparty_wallet.addresses, default_address_key=CosmosCrypto.identifier, ) # create signing message for decision maker to sign terms = Terms( ledger_id=CosmosCrypto.identifier, sender_address=my_aea.identity.address, counterparty_address=counterparty_identity.address, amount_by_currency_id={"FET": -1}, quantities_by_good_id={"some_service": 1}, nonce="some_nonce", fee_by_currency_id={"FET": 0}, ) signing_dialogues = cast(SigningDialogues, skill_context.signing_dialogues) stub_transaction = LedgerApis.get_transfer_transaction( terms.ledger_id, terms.sender_address, terms.counterparty_address, terms.sender_payable_amount, terms.sender_fee, terms.nonce, ) signing_msg = SigningMessage( performative=SigningMessage.Performative.SIGN_TRANSACTION, dialogue_reference=signing_dialogues. new_self_initiated_dialogue_reference(), skill_callback_ids=(str(skill_context.skill_id), ), raw_transaction=RawTransaction(CosmosCrypto.identifier, stub_transaction), terms=terms, skill_callback_info={"some_info_key": "some_info_value"}, ) signing_msg.counterparty = "decision_maker" signing_dialogue = cast(Optional[SigningDialogue], signing_dialogues.update(signing_msg)) assert signing_dialogue is not None my_aea.context.decision_maker_message_queue.put_nowait(signing_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 decision maker time.sleep(1) finally: # Shut down the AEA logger.info("STOPPING AEA NOW!") my_aea.stop() t.join()
def run(): """Run demo.""" # Create a private key create_private_key(FetchAICrypto.identifier, FETCHAI_PRIVATE_KEY_FILE) create_private_key(FetchAICrypto.identifier, FETCHAI_PRIVATE_KEY_FILE_CONNECTION) # Set up the wallet, identity and (empty) resources wallet = Wallet( private_key_paths={FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE}, connection_private_key_paths={ FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE_CONNECTION }, ) identity = Identity( "my_aea", address=wallet.addresses.get(FetchAICrypto.identifier) ) resources = Resources() data_dir = os.getcwd() # specify the default routing for some protocols default_routing = { LedgerApiMessage.protocol_id: LedgerConnection.connection_id, OefSearchMessage.protocol_id: SOEFConnection.connection_id, } default_connection = P2PLibp2pConnection.connection_id state_update_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "state_update") ) resources.add_protocol(state_update_protocol) # Add the default protocol (which is part of the AEA distribution) default_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "default") ) resources.add_protocol(default_protocol) # Add the signing protocol (which is part of the AEA distribution) signing_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "signing") ) resources.add_protocol(signing_protocol) # Add the ledger_api protocol ledger_api_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "ledger_api",) ) resources.add_protocol(ledger_api_protocol) # Add the oef_search protocol oef_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "oef_search",) ) resources.add_protocol(oef_protocol) # Add the fipa protocol fipa_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "fipa",) ) resources.add_protocol(fipa_protocol) # Add the LedgerAPI connection configuration = ConnectionConfig(connection_id=LedgerConnection.connection_id) ledger_api_connection = LedgerConnection( configuration=configuration, data_dir=data_dir, identity=identity ) resources.add_connection(ledger_api_connection) # Add the P2P connection cert_path = ".certs/conn_cert.txt" cert_request = CertRequest( identifier="acn", ledger_id=FetchAICrypto.identifier, not_after="2022-01-01", not_before="2021-01-01", public_key="fetchai", save_path=cert_path, ) public_key = wallet.connection_cryptos.public_keys.get(FetchAICrypto.identifier) message = cert_request.get_message(public_key) make_certificate( FetchAICrypto.identifier, FETCHAI_PRIVATE_KEY_FILE, message, cert_path ) configuration = ConnectionConfig( connection_id=P2PLibp2pConnection.connection_id, delegate_uri="127.0.0.1:11001", entry_peers=[ENTRY_PEER_ADDRESS], local_uri="127.0.0.1:9001", log_file="libp2p_node.log", public_uri="127.0.0.1:9001", build_directory=os.getcwd(), build_entrypoint="check_dependencies.py", cert_requests=[cert_request], ) configuration.directory = os.path.dirname( packages.fetchai.connections.p2p_libp2p.connection.__file__ ) AEABuilder.run_build_for_component_configuration(configuration) p2p_connection = P2PLibp2pConnection( configuration=configuration, data_dir=data_dir, identity=identity, crypto_store=wallet.connection_cryptos, ) resources.add_connection(p2p_connection) # Add the SOEF connection configuration = ConnectionConfig( api_key=API_KEY, soef_addr=SOEF_ADDR, soef_port=SOEF_PORT, restricted_to_protocols={OefSearchMessage.protocol_id}, connection_id=SOEFConnection.connection_id, ) soef_connection = SOEFConnection( configuration=configuration, data_dir=data_dir, identity=identity ) resources.add_connection(soef_connection) # create the AEA my_aea = AEA( identity, wallet, resources, data_dir, default_connection=default_connection, default_routing=default_routing, ) # Add the error and weather_client skills error_skill = Skill.from_dir( os.path.join(ROOT_DIR, "packages", "fetchai", "skills", "error"), agent_context=my_aea.context, ) weather_skill = Skill.from_dir( os.path.join(ROOT_DIR, "packages", "fetchai", "skills", "weather_client"), agent_context=my_aea.context, ) strategy = cast(Strategy, weather_skill.models.get("strategy")) strategy._is_ledger_tx = False for skill in [error_skill, weather_skill]: resources.add_skill(skill) # Run the AEA try: logger.info("STARTING AEA NOW!") my_aea.start() except KeyboardInterrupt: logger.info("STOPPING AEA NOW!") my_aea.stop()
def run(): # Create a private key create_private_key(CosmosCrypto.identifier) # Ensure the input and output files do not exist initially if os.path.isfile(INPUT_FILE): os.remove(INPUT_FILE) if os.path.isfile(OUTPUT_FILE): os.remove(OUTPUT_FILE) # 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(CosmosCrypto.identifier, COSMOS_PRIVATE_KEY_FILE) # Add the echo skill (assuming it is present in the local directory 'packages') builder.add_skill("./packages/fetchai/skills/echo") # create skill and handler manually from aea.protocols.base import Message from aea.protocols.default.message import DefaultMessage from aea.skills.base import Handler class DummyHandler(Handler): """Dummy handler to handle messages.""" SUPPORTED_PROTOCOL = DefaultMessage.protocol_id def setup(self) -> None: """Noop setup.""" def teardown(self) -> None: """Noop teardown.""" def handle(self, message: Message) -> None: """Handle incoming message.""" self.context.logger.info("You got a message: {}".format( str(message))) config = SkillConfig(name="test_skill", author="fetchai") skill = Skill(configuration=config) dummy_handler = DummyHandler(name="dummy_handler", skill_context=skill.skill_context) skill.handlers.update({dummy_handler.name: dummy_handler}) builder.add_component_instance(skill) # Create our AEA my_aea = builder.build() # Set the AEA running in a different thread try: t = Thread(target=my_aea.start) t.start() # Wait for everything to start up time.sleep(4) # Create a message inside an envelope and get the stub connection to pass it on to the echo skill message_text = ( "my_aea,other_agent,fetchai/default:0.3.0,\x08\x01*\x07\n\x05hello," ) with open(INPUT_FILE, "w") as f: f.write(message_text) print("input message: " + message_text) # Wait for the envelope to get processed time.sleep(4) # Read the output envelope generated by the echo skill with open(OUTPUT_FILE, "r") as f: print("output message: " + f.readline()) finally: # Shut down the AEA my_aea.stop() t.join() t = None
def test__create_cosmos_private_key_positive(self, *mocks): """Test _create_cosmos_private_key positive result.""" create_private_key(CosmosCrypto.identifier)
def test__create_ethereum_private_key_positive(self, *mocks): """Test _create_ethereum_private_key positive result.""" create_private_key(EthereumCrypto.identifier)
def run(): # Create a private key create_private_key(FetchAICrypto.identifier, 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(FetchAICrypto.identifier, FETCHAI_PRIVATE_KEY_FILE_1) builder.add_ledger_api_config(FetchAICrypto.identifier, {"network": "testnet"}) # Create our AEA my_aea = builder.build() # Generate some wealth for the default address try_generate_testnet_wealth(FetchAICrypto.identifier, 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_private_key(FetchAICrypto.identifier, private_key_file=FETCHAI_PRIVATE_KEY_FILE_2) counterparty_wallet = Wallet( {FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE_2}) counterparty_identity = Identity( name="counterparty_aea", addresses=counterparty_wallet.addresses, default_address_key=FetchAICrypto.identifier, ) # create tx message for decision maker to process fetchai_ledger_api = my_aea.context.ledger_apis.apis[ FetchAICrypto.identifier] 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=FetchAICrypto.identifier, 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 test__create_ethereum_private_key_positive(self, *mocks): """Test _create_ethereum_private_key positive result.""" create_private_key(EthereumCrypto.identifier, ETHEREUM_PRIVATE_KEY_FILE)
def test__create_cosmos_private_key_positive(self, *mocks): """Test _create_cosmos_private_key positive result.""" create_private_key(CosmosCrypto.identifier, COSMOS_PRIVATE_KEY_FILE)
def run(): # Create a private key create_private_key(CosmosCrypto.identifier) # Set up the wallet, identity and (empty) resources wallet = Wallet( private_key_paths={CosmosCrypto.identifier: COSMOS_PRIVATE_KEY_FILE}, connection_private_key_paths={CosmosCrypto.identifier: COSMOS_PRIVATE_KEY_FILE}, ) identity = Identity("my_aea", address=wallet.addresses.get(CosmosCrypto.identifier)) resources = Resources() # specify the default routing for some protocols default_routing = { PublicId.from_str("fetchai/ledger_api:0.1.0"): LedgerConnection.connection_id, PublicId.from_str("fetchai/oef_search:0.3.0"): SOEFConnection.connection_id, } default_connection = SOEFConnection.connection_id # create the AEA my_aea = AEA( identity, wallet, resources, default_connection=default_connection, default_routing=default_routing, ) # Add the default protocol (which is part of the AEA distribution) default_protocol = Protocol.from_dir(os.path.join(AEA_DIR, "protocols", "default")) resources.add_protocol(default_protocol) # Add the signing protocol (which is part of the AEA distribution) signing_protocol = Protocol.from_dir(os.path.join(AEA_DIR, "protocols", "signing")) resources.add_protocol(signing_protocol) # Add the ledger_api protocol ledger_api_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "ledger_api",) ) resources.add_protocol(ledger_api_protocol) # Add the oef_search protocol oef_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "oef_search",) ) resources.add_protocol(oef_protocol) # Add the fipa protocol fipa_protocol = Protocol.from_dir( os.path.join(os.getcwd(), "packages", "fetchai", "protocols", "fipa",) ) resources.add_protocol(fipa_protocol) # Add the LedgerAPI connection configuration = ConnectionConfig(connection_id=LedgerConnection.connection_id) ledger_api_connection = LedgerConnection( configuration=configuration, identity=identity ) resources.add_connection(ledger_api_connection) # Add the P2P connection configuration = ConnectionConfig( connection_id=P2PLibp2pConnection.connection_id, delegate_uri="127.0.0.1:11001", entry_peers=[ENTRY_PEER_ADDRESS], local_uri="127.0.0.1:9001", log_file="libp2p_node.log", public_uri="127.0.0.1:9001", ) p2p_connection = P2PLibp2pConnection( configuration=configuration, identity=identity, crypto_store=wallet.connection_cryptos, ) resources.add_connection(p2p_connection) # Add the SOEF connection configuration = ConnectionConfig( api_key=API_KEY, soef_addr=SOEF_ADDR, soef_port=SOEF_PORT, restricted_to_protocols={PublicId.from_str("fetchai/oef_search:0.3.0")}, connection_id=SOEFConnection.connection_id, delegate_uri="127.0.0.1:11001", entry_peers=[ENTRY_PEER_ADDRESS], local_uri="127.0.0.1:9001", log_file="libp2p_node.log", public_uri="127.0.0.1:9001", ) soef_connection = SOEFConnection(configuration=configuration, identity=identity) resources.add_connection(soef_connection) # Add the error and weather_client skills error_skill = Skill.from_dir( os.path.join(AEA_DIR, "skills", "error"), agent_context=my_aea.context ) weather_skill = Skill.from_dir( os.path.join(ROOT_DIR, "packages", "fetchai", "skills", "weather_client"), agent_context=my_aea.context, ) strategy = cast(Strategy, weather_skill.models.get("strategy")) strategy._is_ledger_tx = False for skill in [error_skill, weather_skill]: resources.add_skill(skill) # Run the AEA try: logger.info("STARTING AEA NOW!") my_aea.start() except KeyboardInterrupt: logger.info("STOPPING AEA NOW!") my_aea.stop()
def _create_private_key(self, name, ledger) -> str: """Create new key for agent alias in working dir keys dir.""" path = os.path.join(self._keys_dir, f"{name}_{ledger}_private.key") create_private_key(ledger, path) return path
def run(): # Create a private key create_private_key(FetchAICrypto.identifier) # Set up the wallet, identity and (empty) resources wallet = Wallet({FetchAICrypto.identifier: FETCHAI_PRIVATE_KEY_FILE}) identity = Identity("my_aea", address=wallet.addresses.get(FetchAICrypto.identifier)) resources = Resources() # specify the default routing for some protocols default_routing = { PublicId.from_str("fetchai/ledger_api:0.1.0"): LedgerConnection.connection_id } default_connection = OEFConnection.connection_id # create the AEA my_aea = AEA( identity, wallet, resources, default_connection=default_connection, default_routing=default_routing, ) # Add the default protocol (which is part of the AEA distribution) default_protocol = Protocol.from_dir( os.path.join(AEA_DIR, "protocols", "default")) resources.add_protocol(default_protocol) # Add the signing protocol (which is part of the AEA distribution) signing_protocol = Protocol.from_dir( os.path.join(AEA_DIR, "protocols", "signing")) resources.add_protocol(signing_protocol) # Add the ledger_api protocol ledger_api_protocol = Protocol.from_dir( os.path.join( os.getcwd(), "packages", "fetchai", "protocols", "ledger_api", )) resources.add_protocol(ledger_api_protocol) # Add the oef_search protocol oef_protocol = Protocol.from_dir( os.path.join( os.getcwd(), "packages", "fetchai", "protocols", "oef_search", )) resources.add_protocol(oef_protocol) # Add the fipa protocol fipa_protocol = Protocol.from_dir( os.path.join( os.getcwd(), "packages", "fetchai", "protocols", "fipa", )) resources.add_protocol(fipa_protocol) # Add the LedgerAPI connection configuration = ConnectionConfig( connection_id=LedgerConnection.connection_id) ledger_api_connection = LedgerConnection(configuration=configuration, identity=identity) resources.add_connection(ledger_api_connection) # Add the OEF connection configuration = ConnectionConfig(addr=HOST, port=PORT, connection_id=OEFConnection.connection_id) oef_connection = OEFConnection(configuration=configuration, identity=identity) resources.add_connection(oef_connection) # Add the error and weather_client skills error_skill = Skill.from_dir(os.path.join(AEA_DIR, "skills", "error"), agent_context=my_aea.context) weather_skill = Skill.from_dir( os.path.join(ROOT_DIR, "packages", "fetchai", "skills", "weather_client"), agent_context=my_aea.context, ) strategy = cast(Strategy, weather_skill.models.get("strategy")) strategy._is_ledger_tx = False for skill in [error_skill, weather_skill]: resources.add_skill(skill) # Run the AEA try: logger.info("STARTING AEA NOW!") my_aea.start() except KeyboardInterrupt: logger.info("STOPPING AEA NOW!") my_aea.stop()