mm-eth 0.5.16__py3-none-any.whl → 0.6.0__py3-none-any.whl

mm_eth/abi.py

@@ -11,8 +11,6 @@ from pydantic import BaseModel
 from web3 import Web3
 from web3.auto import w3
 
-from mm_eth.utils import hex_to_bytes
-
 
 @dataclass
 class NameTypeValue:
@@ -99,7 +97,7 @@ def encode_function_input_by_signature(func_signature: str, args: list[Any]) ->
     func_abi: ABIFunction = {
         "name": func_name,
         "type": "function",
-        "inputs": [{"type": t} for t in arg_types],  # type: ignore[typeddict-item]
+        "inputs": [{"type": t} for t in arg_types],
     }
     return encode_function_input_by_abi(func_abi, func_name, args)
 
@@ -110,7 +108,7 @@ def encode_function_signature(func_name_with_types: str) -> HexStr:
 
 
 def decode_data(types: list[str], data: str) -> tuple[Any, ...]:
-    return eth_abi.decode(types, hex_to_bytes(data))
+    return eth_abi.decode(types, eth_utils.to_bytes(hexstr=HexStr(data)))
 
 
 def encode_data(types: list[str], args: list[Any]) -> str:

mm_eth/account.py

@@ -1,41 +1,64 @@
 from dataclasses import dataclass
 
-import eth_utils
 from eth_account import Account
 from eth_account.hdaccount import Mnemonic
 from eth_account.signers.local import LocalAccount
 from eth_account.types import Language
 from eth_keys import KeyAPI
-from eth_typing import ChecksumAddress
 from eth_utils import decode_hex
+from mm_std import Result
 
 Account.enable_unaudited_hdwallet_features()
 
 key_api = KeyAPI()
 
+# Default derivation path template for Ethereum HD wallets
 DEFAULT_DERIVATION_PATH = "m/44'/60'/0'/0/{i}"
 
 
 @dataclass
 class DerivedAccount:
+    """Represents an account derived from a mnemonic phrase."""
+
     index: int
     path: str
     address: str
     private_key: str
 
 
-def to_checksum_address(address: str) -> ChecksumAddress:
-    return eth_utils.to_checksum_address(address)
+def generate_mnemonic(num_words: int = 24) -> str:
+    """
+    Generates a BIP39 mnemonic phrase in English.
 
+    Args:
+        num_words (int): Number of words in the mnemonic (12, 15, 18, 21, or 24).
 
-def generate_mnemonic(num_words: int = 24) -> str:
+    Returns:
+        str: Generated mnemonic phrase.
+    """
     mnemonic = Mnemonic(Language.ENGLISH)
     return mnemonic.generate(num_words=num_words)
 
 
 def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit: int) -> list[DerivedAccount]:
+    """
+    Derives multiple Ethereum accounts from a given mnemonic phrase.
+
+    Args:
+        mnemonic (str): BIP39 mnemonic phrase.
+        passphrase (str): Optional BIP39 passphrase.
+        derivation_path (str): Path template with '{i}' as index placeholder.
+        limit (int): Number of accounts to derive.
+
+    Raises:
+        ValueError: If derivation_path does not contain '{i}'.
+
+    Returns:
+        list[DerivedAccount]: List of derived Ethereum accounts.
+    """
     if "{i}" not in derivation_path:
         raise ValueError("derivation_path must contain {i}, for example: " + DEFAULT_DERIVATION_PATH)
+
     result: list[DerivedAccount] = []
     for i in range(limit):
         path = derivation_path.replace("{i}", str(i))
@@ -45,27 +68,37 @@ def derive_accounts(mnemonic: str, passphrase: str, derivation_path: str, limit:
     return result
 
 
-def address_from_private(private_key: str) -> str:
-    """returns address in lower case"""
-    acc: LocalAccount = Account.from_key(private_key)
-    return acc.address.lower()
+def private_to_address(private_key: str, lower: bool = False) -> Result[str]:
+    """
+    Converts a private key to its corresponding Ethereum address.
 
+    Args:
+        private_key (str): Hex-encoded private key.
+        lower (bool): Whether to return address in lowercase.
 
-def private_to_address(private_key: str) -> str | None:
-    """returns address in lower case"""
+    Returns:
+        Result[str]: Ok(address) or Err(exception) on failure.
+    """
     try:
-        return key_api.PrivateKey(decode_hex(private_key)).public_key.to_address().lower()
-    except Exception:
-        return None
+        acc: LocalAccount = Account.from_key(private_key)
+        address = acc.address.lower() if lower else acc.address
+        return Result.ok(address)
+    except Exception as e:
+        return Result.err(e)
 
 
 def is_private_key(private_key: str) -> bool:
+    """
+    Checks if a given hex string is a valid Ethereum private key.
+
+    Args:
+        private_key (str): Hex-encoded private key.
+
+    Returns:
+        bool: True if valid, False otherwise.
+    """
     try:
         key_api.PrivateKey(decode_hex(private_key)).public_key.to_address()
         return True  # noqa: TRY300
     except Exception:
         return False
-
-
-def is_address(address: str) -> bool:
-    return eth_utils.is_address(address)

mm_eth/anvil.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import time
 from subprocess import Popen  # nosec
 
-from mm_std import Err, Ok, Result
+from mm_std import Result
 from mm_std.net import get_free_local_port
 
 from mm_eth import account, rpc
@@ -25,16 +25,16 @@ class Anvil:
         if self.process:
             self.process.kill()
 
-    def check(self) -> bool:
-        res = rpc.eth_chain_id(self.rpc_url)
-        return isinstance(res, Ok) and res.ok == self.chain_id
+    async def check(self) -> bool:
+        res = await rpc.eth_chain_id(self.rpc_url)
+        return res.is_ok() and res.unwrap() == self.chain_id
 
     @property
     def rpc_url(self) -> str:
         return f"http://localhost:{self.port}"
 
     @classmethod
-    def launch(
+    async def launch(
         cls,
         chain_id: int = 31337,
         port: int | None = None,
@@ -49,8 +49,8 @@ class Anvil:
                 port = get_free_local_port()
             anvil = Anvil(chain_id=chain_id, port=port, mnemonic=mnemonic)
             anvil.start_process()
-            if anvil.check():
-                return Ok(anvil)
+            if await anvil.check():
+                return Result.ok(anvil)
             port = get_free_local_port()
 
-        return Err("can't lauch anvil")
+        return Result.err("can't launch anvil")

mm_eth/cli/calcs.py

@@ -1,9 +1,7 @@
-import random
-
 import mm_crypto_utils
 from mm_crypto_utils import VarInt
 
-from mm_eth.constants import SUFFIX_DECIMALS
+from mm_eth.cli.validators import SUFFIX_DECIMALS
 
 
 def calc_eth_expression(expression: str, var: VarInt | None = None) -> int:
@@ -12,16 +10,3 @@ def calc_eth_expression(expression: str, var: VarInt | None = None) -> int:
 
 def calc_token_expression(expression: str, token_decimals: int, var: VarInt | None = None) -> int:
     return mm_crypto_utils.calc_int_expression(expression, var=var, suffix_decimals={"t": token_decimals})
-
-
-def calc_function_args(value: str) -> str:
-    while True:
-        if "random(" not in value:
-            return value
-        start_index = value.index("random(")
-        stop_index = value.index(")", start_index)
-        random_range = [int(v.strip()) for v in value[start_index + 7 : stop_index].split(",")]
-        if len(random_range) != 2:
-            raise ValueError("wrong random(from,to) template")
-        rand_value = str(random.randint(random_range[0], random_range[1]))
-        value = value[0:start_index] + rand_value + value[stop_index + 1 :]

mm_eth/cli/cli.py

@@ -1,4 +1,5 @@
-from enum import Enum
+import asyncio
+import importlib.metadata
 from pathlib import Path
 from typing import Annotated
 
@@ -6,28 +7,11 @@ import typer
 from mm_std import PrintFormat, print_plain
 
 from mm_eth.account import DEFAULT_DERIVATION_PATH
-
-from . import cli_utils
-from .cmd import (
-    balance_cmd,
-    balances_cmd,
-    call_contract_cmd,
-    deploy_cmd,
-    encode_input_data_cmd,
-    example_cmd,
-    node_cmd,
-    rpc_cmd,
-    solc_cmd,
-    token_cmd,
-    transfer_cmd,
-    tx_cmd,
-    vault_cmd,
-)
-from .cmd.balances_cmd import BalancesCmdParams
-from .cmd.call_contract_cmd import CallContractCmdParams
-from .cmd.deploy_cmd import DeployCmdParams
-from .cmd.transfer_cmd import TransferCmdParams
-from .cmd.wallet import mnemonic_cmd, private_key_cmd
+from mm_eth.cli.cmd import balance_cmd, balances_cmd, deploy_cmd, node_cmd, solc_cmd, transfer_cmd
+from mm_eth.cli.cmd.balances_cmd import BalancesCmdParams
+from mm_eth.cli.cmd.deploy_cmd import DeployCmdParams
+from mm_eth.cli.cmd.transfer_cmd import TransferCmdParams
+from mm_eth.cli.cmd.wallet import mnemonic_cmd, private_key_cmd
 
 app = typer.Typer(no_args_is_help=True, pretty_exceptions_enable=False, add_completion=False)
 
@@ -36,50 +20,6 @@ app.add_typer(wallet_app, name="wallet")
 app.add_typer(wallet_app, name="w", hidden=True)
 
 
-class ConfigExample(str, Enum):
-    TRANSFER = "transfer"
-    BALANCES = "balances"
-    CALL_CONTRACT = "call-contract"
-
-
-@app.command(name="balance", help="Gen account balance")
-def balance_command(
-    wallet_address: Annotated[str, typer.Argument()],
-    token_address: Annotated[str | None, typer.Option("--token", "-t")] = None,
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",  # nosec
-    wei: bool = typer.Option(False, "--wei", "-w", help="Print balances in wei units"),
-    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
-) -> None:
-    balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format)
-
-
-@app.command(name="balances", help="Print base and ERC20 token balances")
-def balances_command(
-    config_path: Path,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
-    nonce: bool = typer.Option(False, "--nonce", "-n", help="Print nonce also"),
-    wei: bool = typer.Option(False, "--wei", "-w", help="Show balances in WEI"),
-) -> None:
-    balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config=print_config, wei=wei, show_nonce=nonce))
-
-
-@app.command(name="token", help="Get token info")
-def token_command(
-    token_address: Annotated[str, typer.Argument()],
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",
-) -> None:
-    token_cmd.run(rpc_url, token_address)
-
-
-@app.command(name="node", help="Check RPC url")
-def node_command(
-    urls: Annotated[list[str], typer.Argument()],
-    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
-    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
-) -> None:
-    node_cmd.run(urls, proxy, print_format)
-
-
 @wallet_app.command(name="mnemonic", help="Generate eth accounts based on a mnemonic")
 def mnemonic_command(  # nosec
     mnemonic: Annotated[str, typer.Option("--mnemonic", "-m")] = "",
@@ -106,47 +46,53 @@ def private_key_command(private_key: str) -> None:
     private_key_cmd.run(private_key)
 
 
-@app.command(name="solc", help="Compile a solidity file")
-def solc_command(
-    contract_path: str,
-    tmp_dir: str = "/tmp",  # noqa: S108 # nosec
+@app.command(name="node", help="Check RPC url")
+def node_command(
+    urls: Annotated[list[str], typer.Argument()],
+    proxy: Annotated[str | None, typer.Option("--proxy", "-p", help="Proxy")] = None,
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.TABLE,
+) -> None:
+    asyncio.run(node_cmd.run(urls, proxy, print_format))
+
+
+@app.command(name="balance", help="Gen account balance")
+def balance_command(
+    wallet_address: Annotated[str, typer.Argument()],
+    token_address: Annotated[str | None, typer.Option("--token", "-t")] = None,
+    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL")] = "",  # nosec
+    wei: bool = typer.Option(False, "--wei", "-w", help="Print balances in wei units"),
     print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
 ) -> None:
-    solc_cmd.run(contract_path, tmp_dir, print_format)
+    asyncio.run(balance_cmd.run(rpc_url, wallet_address, token_address, wei, print_format))
 
 
-@app.command(name="vault", help="Save private keys to vault")
-def vault_command(
-    keys_url: Annotated[
-        str,
-        typer.Option(..., "--url", "-u", help="Url to keys, for example https://vault.site.com:8200/v1/kv/keys1"),
-    ],
-    vault_token: Annotated[
-        str,
-        typer.Option(..., "--token", "-t", prompt=True, hide_input=True, prompt_required=False, help="A vault token"),
-    ],
-    keys_file: Annotated[Path, typer.Option(..., "--file", "-f", help="Path to a file with private keys")],
+@app.command(name="balances", help="Print base and ERC20 token balances")
+def balances_command(
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
+    nonce: bool = typer.Option(False, "--nonce", "-n", help="Print nonce also"),
+    wei: bool = typer.Option(False, "--wei", "-w", help="Show balances in WEI"),
 ) -> None:
-    vault_cmd.run(keys_url, vault_token, keys_file)
+    asyncio.run(
+        balances_cmd.run(BalancesCmdParams(config_path=config_path, print_config=print_config, wei=wei, show_nonce=nonce))
+    )
 
 
-@app.command(name="rpc", help="Call a JSON-RPC method")
-def rpc_command(
-    method: Annotated[str, typer.Argument()] = "",
-    params: Annotated[str, typer.Argument()] = "[]",
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL", help="RPC node url")] = "",
-    hex2dec: Annotated[bool, typer.Option("--hex2dec", "-d", help="Print result in decimal value")] = False,
+@app.command(name="solc", help="Compile a solidity file")
+def solc_command(
+    contract_path: Path,
+    tmp_dir: Path = Path("/tmp"),  # noqa: S108 # nosec
+    print_format: Annotated[PrintFormat, typer.Option("--format", "-f", help="Print format")] = PrintFormat.PLAIN,
 ) -> None:
-    rpc_cmd.run(rpc_url, method, params, hex2dec)
+    solc_cmd.run(contract_path, tmp_dir, print_format)
 
 
-@app.command(name="tx", help="Get transaction info by hash")
-def tx_command(
-    tx_hash: Annotated[str, typer.Argument()],
-    rpc_url: Annotated[str, typer.Option("--url", "-u", envvar="MM_ETH_RPC_URL", help="RPC node url")] = "",
-    get_receipt: Annotated[bool, typer.Option("--receipt", "-r", help="Get receipt")] = False,
+@app.command(name="deploy", help="Deploy a smart contract onchain")
+def deploy_command(
+    config_path: Path,
+    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
 ) -> None:
-    tx_cmd.run(rpc_url, tx_hash, get_receipt)
+    asyncio.run(deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config=print_config)))
 
 
 @app.command(
@@ -161,74 +107,24 @@ def transfer_command(
     skip_receipt: bool = typer.Option(False, "--skip-receipt", help="Don't wait for a tx receipt"),
     debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
 ) -> None:
-    transfer_cmd.run(
-        TransferCmdParams(
-            config_path=config_path,
-            print_balances=print_balances,
-            print_transfers=print_transfers,
-            print_config=print_config,
-            debug=debug,
-            skip_receipt=skip_receipt,
-            emulate=emulate,
+    asyncio.run(
+        transfer_cmd.run(
+            TransferCmdParams(
+                config_path=config_path,
+                print_balances=print_balances,
+                print_transfers=print_transfers,
+                print_config=print_config,
+                debug=debug,
+                skip_receipt=skip_receipt,
+                emulate=emulate,
+            )
         )
     )
 
 
-# @app.command(name="send-contract", help="Send transactions to a contract")
-# def send_contract_command(
-#     config_path: Path,
-#     print_balances: bool = typer.Option(False, "--balances", "-b", help="Print balances and exit"),
-#     print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
-#     emulate: bool = typer.Option(False, "--emulate", "-e", help="Emulate transaction posting"),
-#     no_receipt: bool = typer.Option(False, "--no-receipt", "-nr", help="Don't wait for a tx receipt"),
-#     debug: bool = typer.Option(False, "--debug", "-d", help="Print debug info"),
-# ) -> None:
-#     send_contract_cmd.run(
-#         SendContractCmdParams(
-#             config_path=config_path,
-#             print_balances=print_balances,
-#             print_config=print_config,
-#             debug=debug,
-#             no_receipt=no_receipt,
-#             emulate=emulate,
-#         )
-#     )
-
-
-@app.command(name="call-contract", help="Call a method on a contract")
-def call_contract_command(
-    config_path: Path,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
-) -> None:
-    call_contract_cmd.run(CallContractCmdParams(config_path=config_path, print_config=print_config))
-
-
-@app.command(name="deploy", help="Deploy a smart contract onchain")
-def deploy_command(
-    config_path: Path,
-    print_config: bool = typer.Option(False, "--config", "-c", help="Print config and exit"),
-) -> None:
-    deploy_cmd.run(DeployCmdParams(config_path=config_path, print_config=print_config))
-
-
-@app.command(name="example", help="Displays an example configuration for a command")
-def example_command(command: Annotated[ConfigExample, typer.Argument()]) -> None:
-    example_cmd.run(command)
-
-
-@app.command(name="encode-input-data", help="Encode input data by a function signature")
-def encode_input_data(
-    function_signature: str = typer.Argument(help="Function signature, for example: transfer(address, uint256)"),
-    args_str: str = typer.Argument(
-        help="""Function arguments, as an array string. For example: '["0xA659FB44eB5d4bFaC1074Cb426b1b11D58D28308", 123]' """,
-    ),
-) -> None:
-    encode_input_data_cmd.run(function_signature, args_str)
-
-
 def version_callback(value: bool) -> None:
     if value:
-        print_plain(f"mm-eth: {cli_utils.get_version()}")
+        print_plain(f"mm-eth: {importlib.metadata.version('mm-eth')}")
         raise typer.Exit
 
 

mm_eth/cli/cli_utils.py

@@ -1,28 +1,22 @@
 import importlib.metadata
-import time
 from pathlib import Path
-from typing import Literal
 
-from mm_crypto_utils import Nodes, Proxies
-from mm_std import BaseConfig, print_json
+from mm_std import fatal
 from pydantic import BaseModel
+from rich.table import Table
 
 from mm_eth import rpc
 
 
-def get_version() -> str:
-    return importlib.metadata.version("mm-eth")
-
-
 def public_rpc_url(url: str | None) -> str:
     if not url or url == "1":
-        return "https://ethereum.publicnode.com"
+        return "https://ethereum-rpc.publicnode.com"
     if url.startswith(("http://", "https://", "ws://", "wss://")):
         return url
 
     match url.lower():
         case "mainnet" | "1":
-            return "https://ethereum.publicnode.com"
+            return "https://ethereum-rpc.publicnode.com"
         case "sepolia" | "11155111":
             return "https://ethereum-sepolia-rpc.publicnode.com"
         case "opbnb" | "204":
@@ -40,23 +34,16 @@ class BaseConfigParams(BaseModel):
     print_config: bool
 
 
-def print_config(config: BaseConfig, exclude: set[str] | None = None, count: set[str] | None = None) -> None:
-    data = config.model_dump(exclude=exclude)
-    if count:
-        for k in count:
-            data[k] = len(data[k])
-    print_json(data)
+async def check_nodes_for_chain_id(nodes: list[str], chain_id: int) -> None:
+    for node in nodes:
+        res = (await rpc.eth_chain_id(node)).unwrap_or_exit("can't get chain_id")
+        if res != chain_id:
+            fatal(f"node {node} has a wrong chain_id: {res}")
 
 
-def wait_tx_status(nodes: Nodes, proxies: Proxies, tx_hash: str, timeout: int) -> Literal["OK", "FAIL", "TIMEOUT"]:
-    started_at = time.perf_counter()
-    count = 0
-    while True:
-        res = rpc.get_tx_status(nodes, tx_hash, proxies=proxies, attempts=5)
-        if res.is_ok():
-            return "OK" if res.ok == 1 else "FAIL"
+def add_table_raw(table: Table, *row: object) -> None:
+    table.add_row(*[str(cell) for cell in row])
 
-        time.sleep(1)
-        count += 1
-        if time.perf_counter() - started_at > timeout:
-            return "TIMEOUT"
+
+def get_version() -> str:
+    return importlib.metadata.version("mm-eth")

mm_eth/cli/cmd/balance_cmd.py

@@ -1,45 +1,44 @@
+import eth_utils
 from mm_std import PrintFormat, print_json, print_plain
 
-from mm_eth import erc20, rpc
-from mm_eth.cli.cli_utils import public_rpc_url
-from mm_eth.utils import from_wei_str
+from mm_eth import converters, rpc
+from mm_eth.cli import cli_utils
 
 
-def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
+async def run(rpc_url: str, wallet_address: str, token_address: str | None, wei: bool, print_format: PrintFormat) -> None:
     result: dict[str, object] = {}
-    rpc_url = public_rpc_url(rpc_url)
+    rpc_url = cli_utils.public_rpc_url(rpc_url)
 
     # nonce
-    result["nonce"] = rpc.eth_get_transaction_count(rpc_url, wallet_address).ok_or_err()
+    result["nonce"] = (await rpc.eth_get_transaction_count(rpc_url, wallet_address)).value_or_error()
     if print_format == PrintFormat.PLAIN:
         print_plain(f"nonce: {result['nonce']}")
 
     # eth balance
     result["eth_balance"] = (
-        rpc.eth_get_balance(rpc_url, wallet_address).map(lambda x: str(x) if wei else from_wei_str(x, "eth")).ok_or_err()
+        (await rpc.eth_get_balance(rpc_url, wallet_address))
+        .map(lambda value: value if wei else eth_utils.from_wei(value, "ether"))
+        .value_or_error()
     )
     if print_format == PrintFormat.PLAIN:
         print_plain(f"eth_balance: {result['eth_balance']}")
 
     if token_address:
         # token decimal
-        result["token_decimal"] = erc20.get_decimals(rpc_url, token_address).ok_or_err()
+        result["token_decimal"] = (await rpc.erc20_decimals(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
             print_plain(f"token_decimal: {result['token_decimal']}")
 
         # token symbol
-        result["token_symbol"] = erc20.get_symbol(rpc_url, token_address).ok_or_err()
+        result["token_symbol"] = (await rpc.erc20_symbol(rpc_url, token_address)).value_or_error()
         if print_format == PrintFormat.PLAIN:
             print_plain(f"token_symbol: {result['token_symbol']}")
 
         # token balance
-        result["token_balance"] = (
-            erc20.get_balance(rpc_url, token_address, wallet_address)
-            .map(
-                lambda x: str(x) if wei or not result["token_decimal"] else from_wei_str(x, "t", decimals=result["token_decimal"])  # type: ignore[arg-type]
-            )
-            .ok_or_err()
-        )
+        result["token_balance"] = (await rpc.erc20_balance(rpc_url, token_address, wallet_address)).value_or_error()
+        if isinstance(result["token_balance"], int) and not wei and isinstance(result["token_decimal"], int):
+            result["token_balance"] = converters.from_wei(result["token_balance"], "t", decimals=result["token_decimal"])
+
         if print_format == PrintFormat.PLAIN:
             print_plain(f"token_balance: {result['token_balance']}")