repository·main·Indexed 43 days ago
https://github.com/apeworx/eth-accountA Python library for signing Ethereum transactions and messages locally using private keys. It provides primitives for account management, cryptographic signing, and support for Typed Transactions including EIP-1559 (Dynamic Fee), Access List, and EIP-4844 (Blob) transactions. Features include private key encryption/decryption, EIP-712 typed data signing, EIP-7702 authorization signing, and experimental BIP39 mnemonic support.
eth-account is a Python library designed to sign Ethereum transactions and messages using local private keys. It provides the necessary primitives for managing accounts and cryptographic signing operations locally without requiring a connection to a live node for the signing process itself.Local Signer is currently the primary implementation for abstracting a private key. It allows you to perform signing operations without manually handling the raw private key in every function call. While currently limited to local key management, the architecture is designed to support future implementations like Hierarchical Deterministic (HD) wallets and hardware wallets.In eth-account, there is a distinction between the Account class and Signer classes:
Account: Requires the private key to be explicitly provided on each usage.All signer classes in this package implement the interface defined by BaseAccount.
eth-account library provides specialized classes for different Ethereum transaction types, known as Typed Transactions. Instead of manually constructing raw transaction dictionaries, you can use these classes to ensure the correct structure and parameters for specific EIPs (Ethereum Improvement Proposals).Install the eth-account package using pip to enable signing Ethereum transactions and messages with local private keys.
python -m pip install eth-accountA SignableMessage is a NamedTuple representing a message compatible with the EIP-191 standard, prepared for signing. It consists of three components:
version: A single byte representing the message version.header: Version-specific data (e.g., a validator address or a domain hash).body: The actual data to be signed.In typical usage, you should not create these manually. Instead, use the encoding utility functions like encode_intended_validator, encode_defunct, or encode_typed_data to generate them.
from eth_account.messages import SignableMessage
# SignableMessage is a NamedTuple with:
# version: bytes
# header: bytes
# body: bytesThe signing methods in Account (such as sign_typed_data and sign_authorization) accept several types for the private_key parameter:
hex str (e.g., "0x...")bytesinteth_keys.datatypes.PrivateKey objectsIf a hex string or bytes are provided, they are parsed into a PrivateKey object. The key must be exactly 32 bytes long.
BlobTransaction class to create transactions that include EIP-4844 blobs. These are used for data availability improvements in Ethereum.SetCodeTransaction class to create transactions specifically designed to change the code of an account (typically used in contract deployment or updates).DynamicFeeTransaction class to create EIP-1559 style transactions. These transactions use max_fee_per_gas and max_priority_fee_per_gas instead of a single gas_price to provide more predictable fee management.AccessListTransaction class to create transactions that include an access list. This is used to optimize gas costs by pre-specifying the accounts and storage keys that will be accessed during execution.Use Account.create() to generate a new private key and return a LocalAccount object. You can provide extra_entropy (str, bytes, or int) to add additional randomness to the key generation process.
from eth_account import Account
# Create a new account with optional extra entropy
acct = Account.create('KEYSMASH FJAFJKLDSKF7JKFDJ 1530')
print(acct.address)
print(acct.key)