plugins.aea-ledger-ethereum.aea`_`ledger`_`ethereum.ethereum¶

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

get`_`gas`_`price`_`strategy¶

def get_gas_price_strategy(
        gas_price_strategy: Optional[str] = None,
        api_key: Optional[str] = None) -> Callable[[Web3, TxParams], Wei]

Get the gas price strategy.

SignedTransactionTranslator Objects¶

class SignedTransactionTranslator()

Translator for SignedTransaction.

to`_`dict¶

@staticmethod
def to_dict(
        signed_transaction: SignedTransaction) -> Dict[str, Union[str, int]]

Write SignedTransaction to dict.

from`_`dict¶

@staticmethod
def from_dict(signed_transaction_dict: JSONLike) -> SignedTransaction

Get SignedTransaction from dict.

AttributeDictTranslator Objects¶

class AttributeDictTranslator()

Translator for AttributeDict.

to`_`dict¶

@classmethod
def to_dict(cls, attr_dict: Union[AttributeDict, TxReceipt,
                                  TxData]) -> JSONLike

Simplify to dict.

from`_`dict¶

@classmethod
def from_dict(cls, di: JSONLike) -> AttributeDict

Get back attribute dict.

EthereumCrypto Objects¶

class EthereumCrypto(Crypto[Account])

Class wrapping the Account Generation from Ethereum ledger.

``init``¶

def __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
def private_key() -> str

Return a private key.

Returns:

a private key string

public`_`key¶

@property
def public_key() -> str

Return a public key in hex format.

Returns:

a public key string in hex format

address¶

@property
def address() -> str

Return the address for the key pair.

Returns:

a display_address str

load`_`private`_`key`_`from`_`path¶

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

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¶

def 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¶

def 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
def generate_private_key(cls) -> Account

Generate a key pair for ethereum network.

encrypt¶

def 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
def decrypt(cls, keyfile_json: str, password: str) -> str

Decrypt the private key and return in raw form.

Arguments:

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

Returns:

the raw private key.

EthereumHelper Objects¶

class EthereumHelper(Helper)

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

is`_`transaction`_`settled¶

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

Check whether a transaction is settled or not.

Arguments:

tx_receipt: the receipt associated to the transaction.

Returns:

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

get`_`contract`_`address¶

@staticmethod
def 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
def is_transaction_valid(tx: dict, 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
def 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
def 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
def 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
def 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
def get_hash(message: bytes) -> str

Get the hash of a message.

Arguments:

message: the message to be hashed.

Returns:

the hash of the message.

load`_`contract`_`interface¶

@classmethod
def 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

EthereumApi Objects¶

class EthereumApi(LedgerApi, EthereumHelper)

Class to interact with the Ethereum Web3 APIs.

``init``¶

def __init__(**kwargs: Any)

Initialize the Ethereum ledger APIs.

Arguments:

kwargs: keyword arguments

api¶

@property
def api() -> Web3

Get the underlying API object.

get`_`balance¶

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

Get the balance of a given account.

get`_`state¶

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

Call a specified function on the ledger API.

get`_`transfer`_`transaction¶

def get_transfer_transaction(sender_address: Address,
                             destination_address: Address,
                             amount: int,
                             tx_fee: int,
                             tx_nonce: str,
                             chain_id: Optional[int] = None,
                             gas_price: Optional[str] = None,
                             gas_price_strategy: 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 (in Wei).
tx_fee: the transaction fee (gas) to be used (in Wei).
tx_nonce: verifies the authenticity of the tx.
chain_id: the Chain ID of the Ethereum transaction.
gas_price: the gas price (in Wei)
gas_price_strategy: the gas price strategy to be used.
kwargs: keyword arguments

Returns:

the transfer transaction

update`_`with`_`gas`_`estimate¶

def update_with_gas_estimate(transaction: JSONLike) -> JSONLike

Attempts to update the transaction with a gas estimate

Arguments:

transaction: the transaction

Returns:

the updated transaction

send`_`signed`_`transaction¶

def 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¶

def 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¶

def 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¶

def 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

get`_`deploy`_`transaction¶

def get_deploy_transaction(contract_interface: Dict[str, str],
                           deployer_address: Address,
                           value: int = 0,
                           gas: int = 0,
                           gas_price: Optional[str] = None,
                           gas_price_strategy: Optional[str] = None,
                           **kwargs: Any) -> Optional[JSONLike]

Get the transaction to deploy the smart contract.

Arguments:

contract_interface: the contract interface.
deployer_address: The address that will deploy the contract.
value: value to send to contract (in Wei)
gas: the gas to be used (in Wei)
gas_price: the gas price (in Wei)
gas_price_strategy: the gas price strategy to be used.
kwargs: keyword arguments

Returns:

the transaction dictionary.

is`_`valid`_`address¶

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

Check if the address is valid.

Arguments:

address: the address to validate

Returns:

whether the address is valid

EthereumFaucetApi Objects¶

class EthereumFaucetApi(FaucetApi)

Ethereum testnet faucet API.

get`_`wealth¶

def 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

LruLockWrapper Objects¶

class LruLockWrapper()

Wrapper for LRU with threading.Lock.

``init``¶

def __init__(lru: LRU) -> None

Init wrapper.

``getitem``¶

def __getitem__(*args: Any, **kwargs: Any) -> Any

Get item

``setitem``¶

def __setitem__(*args: Any, **kwargs: Any) -> Any

Set item.

``contains``¶

def __contains__(*args: Any, **kwargs: Any) -> Any

Contain item.

``delitem``¶

def __delitem__(*args: Any, **kwargs: Any) -> Any

Del item.

set`_`wrapper`_`for`_`web3py`_`session`_`cache¶

def set_wrapper_for_web3py_session_cache() -> None

Wrap web3py session cache with threading.Lock.

plugins.aea-ledger-ethereum.aea_ledger_ethereum.ethereum¶

get_gas_price_strategy¶

SignedTransactionTranslator Objects¶

to_dict¶

from_dict¶

AttributeDictTranslator Objects¶

to_dict¶

from_dict¶

EthereumCrypto Objects¶

__init__¶

private_key¶

public_key¶

address¶

load_private_key_from_path¶

sign_message¶

sign_transaction¶

generate_private_key¶

encrypt¶

decrypt¶

EthereumHelper Objects¶

is_transaction_settled¶

get_contract_address¶

is_transaction_valid¶

generate_tx_nonce¶

get_address_from_public_key¶

recover_message¶

recover_public_keys_from_message¶

get_hash¶

load_contract_interface¶

EthereumApi Objects¶

__init__¶

api¶

get_balance¶

get_state¶

get_transfer_transaction¶

update_with_gas_estimate¶

send_signed_transaction¶

get_transaction_receipt¶

get_transaction¶

get_contract_instance¶

get_deploy_transaction¶

is_valid_address¶

EthereumFaucetApi Objects¶

get_wealth¶

LruLockWrapper Objects¶

__init__¶

__getitem__¶

__setitem__¶

__contains__¶

__delitem__¶

set_wrapper_for_web3py_session_cache¶

plugins.aea-ledger-ethereum.aea`_`ledger`_`ethereum.ethereum¶

get`_`gas`_`price`_`strategy¶

to`_`dict¶

from`_`dict¶

to`_`dict¶

from`_`dict¶

``init``¶

private`_`key¶

public`_`key¶

load`_`private`_`key`_`from`_`path¶

sign`_`message¶

sign`_`transaction¶

generate`_`private`_`key¶

is`_`transaction`_`settled¶

get`_`contract`_`address¶

is`_`transaction`_`valid¶

generate`_`tx`_`nonce¶

get`_`address`_`from`_`public`_`key¶

recover`_`message¶

recover`_`public`_`keys`_`from`_`message¶

get`_`hash¶

load`_`contract`_`interface¶

``init``¶

get`_`balance¶

get`_`state¶

get`_`transfer`_`transaction¶

update`_`with`_`gas`_`estimate¶

send`_`signed`_`transaction¶

get`_`transaction`_`receipt¶

get`_`transaction¶

get`_`contract`_`instance¶

get`_`deploy`_`transaction¶

is`_`valid`_`address¶

get`_`wealth¶

``init``¶

``getitem``¶

``setitem``¶

``contains``¶

``delitem``¶

set`_`wrapper`_`for`_`web3py`_`session`_`cache¶