Skip to content

plugins.aea-ledger-cosmos.aea_ledger_cosmos.cosmos

Cosmos module wrapping the public and private key cryptography and ledger api.

DataEncrypt Objects

class DataEncrypt()

Class to encrypt/decrypt data strings with password provided.

encrypt

 | @classmethod
 | encrypt(cls, data: bytes, password: str) -> bytes

Encrypt data with password.

bytes_encode

 | @staticmethod
 | bytes_encode(data: bytes) -> str

Encode bytes to ascii friendly string.

bytes_decode

 | @staticmethod
 | bytes_decode(data: str) -> bytes

Decode ascii friendly string to bytes.

decrypt

 | @classmethod
 | decrypt(cls, encrypted_data: bytes, password: str) -> bytes

Decrypt data with password provided.

CosmosHelper Objects

class CosmosHelper(Helper)

Helper class usable as Mixin for CosmosApi or as standalone class.

is_transaction_settled

 | @staticmethod
 | is_transaction_settled(tx_receipt: JSONLike) -> bool

Check whether a transaction is settled or not.

Arguments:

  • tx_receipt: the receipt of the transaction.

Returns:

True if the transaction has been settled, False o/w.

get_code_id

 | @staticmethod
 | get_code_id(tx_receipt: JSONLike) -> Optional[int]

Retrieve the code_id from a transaction receipt.

Arguments:

  • tx_receipt: the receipt of the transaction.

Returns:

the code id, if present

get_contract_address

 | @staticmethod
 | get_contract_address(tx_receipt: JSONLike) -> Optional[str]

Retrieve the contract_address from a transaction receipt.

Arguments:

  • tx_receipt: the receipt of the transaction.

Returns:

the contract address, if present

is_transaction_valid

 | @staticmethod
 | is_transaction_valid(tx: JSONLike, seller: Address, client: Address, tx_nonce: str, amount: int) -> bool

Check whether a transaction is valid or not.

Arguments:

  • tx: the transaction.
  • seller: the address of the seller.
  • client: the address of the client.
  • tx_nonce: the transaction nonce.
  • amount: the amount we expect to get from the transaction.

Returns:

True if the random_message is equals to tx['input']

generate_tx_nonce

 | @staticmethod
 | generate_tx_nonce(seller: Address, client: Address) -> str

Generate a unique hash to distinguish transactions with the same terms.

Arguments:

  • seller: the address of the seller.
  • client: the address of the client.

Returns:

return the hash in hex.

get_address_from_public_key

 | @classmethod
 | get_address_from_public_key(cls, public_key: str) -> str

Get the address from the public key.

Arguments:

  • public_key: the public key

Returns:

str

recover_message

 | @classmethod
 | recover_message(cls, message: bytes, signature: str, is_deprecated_mode: bool = False) -> Tuple[Address, ...]

Recover the addresses from the hash.

Arguments:

  • message: the message we expect
  • signature: the transaction signature
  • is_deprecated_mode: if the deprecated signing was used

Returns:

the recovered addresses

recover_public_keys_from_message

 | @classmethod
 | recover_public_keys_from_message(cls, message: bytes, signature: str, is_deprecated_mode: bool = False) -> Tuple[str, ...]

Get the public key used to produce the signature of the message

Arguments:

  • message: raw bytes used to produce signature
  • signature: signature of the message
  • is_deprecated_mode: if the deprecated signing was used

Returns:

the recovered public keys

get_hash

 | @staticmethod
 | get_hash(message: bytes) -> str

Get the hash of a message.

Arguments:

  • message: the message to be hashed.

Returns:

the hash of the message.

is_valid_address

 | @classmethod
 | is_valid_address(cls, address: Address) -> bool

Check if the address is valid.

Arguments:

  • address: the address to validate

Returns:

whether address is valid or not

load_contract_interface

 | @classmethod
 | load_contract_interface(cls, file_path: Path) -> Dict[str, str]

Load contract interface.

Arguments:

  • file_path: the file path to the interface

Returns:

the interface

CosmosCrypto Objects

class CosmosCrypto(Crypto[SigningKey])

Class wrapping the Account Generation from Ethereum ledger.

__init__

 | __init__(private_key_path: Optional[str] = None, password: Optional[str] = None) -> None

Instantiate an ethereum crypto object.

Arguments:

  • private_key_path: the private key path of the agent
  • password: the password to encrypt/decrypt the private key.

private_key

 | @property
 | private_key() -> str

Return a private key.

Returns:

a private key string

public_key

 | @property
 | public_key() -> str

Return a public key in hex format.

Returns:

a public key string in hex format

address

 | @property
 | address() -> str

Return the address for the key pair.

Returns:

a display_address str

load_private_key_from_path

 | @classmethod
 | load_private_key_from_path(cls, file_name: str, password: Optional[str] = None) -> SigningKey

Load a private key in hex format from a file.

Arguments:

  • file_name: the path to the hex file.
  • password: the password to encrypt/decrypt the private key.

Returns:

the Entity.

sign_message

 | sign_message(message: bytes, is_deprecated_mode: bool = False) -> str

Sign a message in bytes string form.

Arguments:

  • message: the message to be signed
  • is_deprecated_mode: if the deprecated signing is used

Returns:

signature of the message in string form

sign_transaction

 | sign_transaction(transaction: JSONLike) -> JSONLike

Sign a transaction in bytes string form.

Arguments:

  • transaction: the transaction to be signed

Returns:

signed transaction

generate_private_key

 | @classmethod
 | generate_private_key(cls) -> SigningKey

Generate a key pair for cosmos network.

encrypt

 | encrypt(password: str) -> str

Encrypt the private key and return in json.

Arguments:

  • password: the password to decrypt.

Returns:

json string containing encrypted private key.

decrypt

 | @classmethod
 | decrypt(cls, keyfile_json: str, password: str) -> str

Decrypt the private key and return in raw form.

Arguments:

  • keyfile_json: json string containing encrypted private key.
  • password: the password to decrypt.

Returns:

the raw private key.

_CosmosApi Objects

class _CosmosApi(LedgerApi)

Class to interact with the Cosmos SDK via a HTTP APIs.

__init__

 | __init__(**kwargs: Any) -> None

Initialize the Cosmos ledger APIs.

api

 | @property
 | api() -> Any

Get the underlying API object.

get_balance

 | get_balance(address: Address) -> Optional[int]

Get the balance of a given account.

get_state

 | get_state(callable_name: str, *args: Any, **kwargs: Any) -> Optional[JSONLike]

Call a specified function on the ledger API.

Based on the cosmos REST API specification, which takes a path (strings separated by '/'). The convention here is to define the root of the path (txs, blocks, etc.) as the callable_name and the rest of the path as args.

Arguments:

  • callable_name: name of the callable
  • args: positional arguments
  • kwargs: keyword arguments

Returns:

the transaction dictionary

get_deploy_transaction

 | get_deploy_transaction(contract_interface: Dict[str, str], deployer_address: Address, **kwargs: Any, ,) -> Optional[JSONLike]

Get the transaction to deploy the smart contract.

Dispatches to _get_storage_transaction and _get_init_transaction based on kwargs.

Arguments:

  • contract_interface: the contract interface.
  • deployer_address: The address that will deploy the contract.
  • kwargs: keyword arguments.

Returns:

the transaction dictionary.

get_handle_transaction

 | get_handle_transaction(sender_address: Address, contract_address: Address, handle_msg: Any, amount: int, tx_fee: int, denom: Optional[str] = None, gas: int = DEFAULT_GAS_AMOUNT, memo: str = "", chain_id: Optional[str] = None, account_number: Optional[int] = None, sequence: Optional[int] = None, tx_fee_denom: Optional[str] = None) -> Optional[JSONLike]

Create a CosmWasm HandleMsg transaction.

Arguments:

  • sender_address: the sender address of the message initiator.
  • contract_address: the address of the smart contract.
  • handle_msg: HandleMsg in JSON format.
  • amount: Funds amount sent with transaction.
  • tx_fee: the tx fee accepted.
  • denom: the name of the denomination of the contract funds
  • gas: Maximum amount of gas to be used on executing command.
  • memo: any string comment.
  • chain_id: the Chain ID of the CosmWasm transaction. Default is 1 (i.e. mainnet).
  • account_number: Account number
  • sequence: Sequence
  • tx_fee_denom: Denomination of tx_fee, identical with denom param when None

Returns:

the unsigned CosmWasm HandleMsg

execute_contract_query

 | execute_contract_query(contract_address: Address, query_msg: JSONLike) -> Optional[JSONLike]

Execute a CosmWasm QueryMsg. QueryMsg doesn't require signing.

Arguments:

  • contract_address: the address of the smart contract.
  • query_msg: QueryMsg in JSON format.

Returns:

the message receipt

get_transfer_transaction

 | get_transfer_transaction(sender_address: Address, destination_address: Address, amount: int, tx_fee: int, tx_nonce: str, denom: Optional[str] = None, gas: int = DEFAULT_GAS_AMOUNT, memo: str = "", chain_id: Optional[str] = None, account_number: Optional[int] = None, sequence: Optional[int] = None, tx_fee_denom: Optional[str] = None, **kwargs: Any, ,) -> Optional[JSONLike]

Submit a transfer transaction to the ledger.

Arguments:

  • sender_address: the sender address of the payer.
  • destination_address: the destination address of the payee.
  • amount: the amount of wealth to be transferred.
  • tx_fee: the transaction fee.
  • tx_nonce: verifies the authenticity of the tx
  • denom: the denomination of tx fee and amount
  • gas: the gas used.
  • memo: memo to include in tx.
  • chain_id: the chain ID of the transaction.
  • account_number: Account number
  • sequence: Sequence
  • tx_fee_denom: Denomination of tx_fee, identical with denom param when None
  • kwargs: keyword arguments.

Returns:

the transfer transaction

get_packed_exec_msg

 | get_packed_exec_msg(sender_address: Address, contract_address: str, msg: JSONLike, funds: int = 0, denom: Optional[str] = None) -> ProtoAny

Create and pack MsgExecuteContract

Arguments:

  • sender_address: Address of sender
  • contract_address: Address of contract
  • msg: Paramaters to be passed to smart contract
  • funds: Funds to be sent to smart contract
  • denom: the denomination of funds

Returns:

Packed MsgExecuteContract

get_packed_send_msg

 | get_packed_send_msg(from_address: Address, to_address: Address, amount: int, denom: Optional[str] = None) -> ProtoAny

Generate and pack MsgSend

Arguments:

  • from_address: Address of sender
  • to_address: Address of recipient
  • amount: amount of coins to be sent
  • denom: the denomination of and amount

Returns:

packer ProtoAny type message

get_multi_transaction

 | get_multi_transaction(from_addresses: List[str], pub_keys: Optional[List[bytes]], msgs: List[ProtoAny], gas: int, tx_fee: int = 0, memo: str = "", chain_id: Optional[str] = None, denom: Optional[str] = None, tx_fee_denom: Optional[str] = None) -> JSONLike

Generate transaction with multiple messages

Arguments:

  • from_addresses: Addresses of signers
  • pub_keys: Public keys of signers
  • msgs: Messages to be included in transaction
  • gas: the gas used.
  • tx_fee: the transaction fee.
  • memo: memo to include in tx.
  • chain_id: the chain ID of the transaction.
  • denom: the denomination of tx fee
  • tx_fee_denom: Denomination of tx_fee, identical with denom param when None

:raises: RuntimeError if number of pubkeys is not equal to number of from_addresses

Returns:

the transaction

send_signed_transaction

 | send_signed_transaction(tx_signed: JSONLike) -> Optional[str]

Send a signed transaction and wait for confirmation.

Arguments:

  • tx_signed: the signed transaction

Returns:

tx_digest, if present

get_transaction_receipt

 | get_transaction_receipt(tx_digest: str) -> Optional[JSONLike]

Get the transaction receipt for a transaction digest.

Arguments:

  • tx_digest: the digest associated to the transaction.

Returns:

the tx receipt, if present

get_transaction

 | get_transaction(tx_digest: str) -> Optional[JSONLike]

Get the transaction for a transaction digest.

Arguments:

  • tx_digest: the digest associated to the transaction.

Returns:

the tx, if present

get_contract_instance

 | get_contract_instance(contract_interface: Dict[str, str], contract_address: Optional[str] = None) -> Any

Get the instance of a contract.

Arguments:

  • contract_interface: the contract interface.
  • contract_address: the contract address.

Returns:

the contract instance

update_with_gas_estimate

 | update_with_gas_estimate(transaction: JSONLike) -> JSONLike

Attempts to update the transaction with a gas estimate

Arguments:

  • transaction: the transaction :raises: NotImplementedError

CosmosApi Objects

class CosmosApi(_CosmosApi,  CosmosHelper)

Class to interact with the Cosmos SDK via a HTTP APIs.

CosmosFaucetApi Objects

class CosmosFaucetApi(FaucetApi)

Cosmos testnet faucet API.

__init__

 | __init__(poll_interval: Optional[float] = None, final_wait_interval: Optional[float] = None)

Initialize CosmosFaucetApi.

get_wealth

 | get_wealth(address: Address, url: Optional[str] = None) -> None

Get wealth from the faucet for the provided address.

Arguments:

  • address: the address.
  • url: the url :raises: RuntimeError of explicit faucet failures