def do_transfer(ctx: Context, identifier: str, address: Address, amount: int,
tx_fee: int) -> Optional[str]:
"""
Perform wealth transfer to another account.
:param ctx: click context
:param identifier: str, ledger id to perform transfer operation
:param address: address of the recepient
:param amount: int, amount of wealth to transfer
:param tx_fee: int, fee for transaction
:return: str, transaction digest or None if failed.
"""
click.echo("Starting transfer ...")
wallet = get_wallet_from_context(ctx)
source_address = wallet.addresses[identifier]
_override_ledger_configurations(ctx.agent_config)
balance = int(try_get_balance(ctx.agent_config, wallet, identifier))
total_payable = amount + tx_fee
if total_payable > balance:
raise click.ClickException(
f"Balance is not enough! Available={balance}, required={total_payable}!"
)
tx_nonce = LedgerApis.generate_tx_nonce(identifier, source_address,
address)
transaction = LedgerApis.get_transfer_transaction(identifier,
source_address, address,
amount, tx_fee, tx_nonce)
tx_signed = wallet.sign_transaction(identifier, transaction)
return LedgerApis.send_signed_transaction(identifier, tx_signed)
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 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 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()