mm-eth 0.1.0__py3-none-any.whl

mm_eth/utils.py

@@ -0,0 +1,245 @@
+import re
+from decimal import Decimal, localcontext
+from typing import Any, cast
+
+import eth_utils
+import pydash
+from eth_typing import HexStr
+from hexbytes import HexBytes
+from mm_std import Err, Ok, Result, number_with_separator, random_choice
+from mm_std.random_ import random_str_choice
+from pydantic import BaseModel
+from web3 import Web3
+from web3.types import Wei
+
+from mm_eth.types import Nodes, Proxies
+
+
+def parse_addresses(data: str) -> list[str]:
+    data = data.lower()
+    result = []
+    for word in data.split():
+        if len(word) == 42 and re.match("0x[a-f0-9]{40}", word):
+            result.append(word)
+    return pydash.uniq(result)
+
+
+def to_token_wei(value: str | int, decimals: int) -> int:
+    if isinstance(value, int):
+        return value
+    elif isinstance(value, str):
+        value = value.lower().replace(" ", "").strip()
+        if value.endswith("t"):
+            value = value.replace("t", "")
+            return int(Decimal(value) * 10**decimals)
+        elif value.isdigit():
+            return int(value)
+
+    raise ValueError("wrong value" + value)
+
+
+def to_wei(value: str | int | Decimal, decimals: int | None = None) -> Wei:
+    if isinstance(value, int):
+        return Wei(value)
+    elif isinstance(value, Decimal):
+        if value != value.to_integral_value():
+            raise ValueError(f"value must be integral number: {value}")
+        return Wei(int(value))
+    elif isinstance(value, str):
+        value = value.lower().replace(" ", "").strip()
+        if value.endswith("navax"):  # https://snowtrace.io/unitconverter
+            value = value.replace("navax", "")
+            return Wei(int(Decimal(value) * 10**9))
+        if value.endswith("gwei"):
+            value = value.replace("gwei", "")
+            return Wei(int(Decimal(value) * 1000000000))
+        if value.endswith("ether"):
+            value = value.replace("ether", "")
+            return Wei(int(Decimal(value) * 1000000000000000000))
+        if value.endswith("eth"):
+            value = value.replace("eth", "")
+            return Wei(int(Decimal(value) * 1000000000000000000))
+        if value.endswith("t"):
+            if decimals is None:
+                raise ValueError("t without decimals")
+            value = value.removesuffix("t")
+            return Wei(int(Decimal(value) * 10**decimals))
+        if value.isdigit():
+            return Wei(int(value))
+        raise ValueError("wrong value " + value)
+
+    else:
+        raise ValueError(f"value has a wrong type: {type(value)}")
+
+
+def from_wei(
+    value: int,
+    unit: str,
+    round_ndigits: int | None = None,
+    decimals: int | None = None,
+) -> Decimal:
+    if value == 0:
+        return Decimal(0)
+
+    is_negative = value < 0
+    if unit.lower() == "eth":
+        unit = "ether"
+
+    if unit.lower() == "t":
+        if decimals is None:
+            raise ValueError("t without decimals")
+        with localcontext() as ctx:
+            ctx.prec = 999
+            res = Decimal(value=abs(value), context=ctx) / Decimal(10**decimals)
+    else:
+        res = cast(Decimal, eth_utils.from_wei(abs(value), unit))
+    if round_ndigits is not None:
+        res = round(res, ndigits=round_ndigits)
+    return -1 * res if is_negative else res
+
+
+def from_wei_str(
+    value: int,
+    unit: str,
+    round_ndigits: int | None = None,
+    print_unit_name: bool = True,
+    decimals: int | None = None,
+) -> str:
+    res = format(from_wei(value, unit, round_ndigits, decimals=decimals), "f")
+    if unit == "ether":
+        unit = "eth"
+    if print_unit_name:
+        res += unit
+    return res
+
+
+def from_token_wei_str(value: int, decimals: int, symbol: str = "", round_ndigits: int | None = None) -> str:
+    res = value / 10**decimals
+    if round_ndigits is not None:
+        res = round(res, ndigits=round_ndigits)
+    if symbol:
+        res = f"{res} {symbol}"
+    return str(res)
+
+
+def to_wei_token(value: str | int | Decimal, symbol: str, decimals: int) -> int:
+    if isinstance(value, int):
+        return value
+    elif isinstance(value, Decimal):
+        if value != value.to_integral_value():
+            raise ValueError(f"value must be integral number: {value}")
+        return int(value)
+    elif isinstance(value, str):
+        value = value.lower().replace(" ", "").strip()
+        if value.isdigit():
+            return int(value)
+        try:
+            return int(Decimal(value.replace(symbol.lower(), "").strip()) * (10**decimals))
+        except Exception as e:
+            raise ValueError from e
+    else:
+        raise ValueError(f"value has a wrong type: {type(value)}")
+
+
+def to_checksum_address(address: str) -> str:
+    return Web3.to_checksum_address(address)
+
+
+def hex_to_bytes(data: str) -> bytes:
+    return eth_utils.to_bytes(hexstr=HexStr(data))
+
+
+def get_chain_name(chain_id: int | str) -> str:
+    chain_id = str(chain_id)
+    if chain_id == "1":
+        return "mainnet"
+    if chain_id == "3":
+        return "ropsten"
+    if chain_id == "5":
+        return "goerli"
+    return chain_id
+
+
+def to_human_readable_tx(tx: dict[str, Any] | BaseModel) -> dict[str, object]:
+    if isinstance(tx, BaseModel):
+        tx = tx.model_dump()
+    tx["human_readable"] = {}
+    tx["human_readable"]["gas_price"] = str(tx["gas_price"] / 10**9) + " gwei"
+    tx["human_readable"]["value"] = str(tx["value"] / 10**18) + " ether"
+    tx["human_readable"]["gas"] = number_with_separator(tx["gas"])
+    if tx.get("chain_id") is not None:
+        tx["human_readable"]["chain_id"] = get_chain_name(tx["chain_id"])
+
+    return tx
+
+
+def truncate_hex_str(hex_str: str, digits: int = 4, replace_str: str = "...") -> str:
+    if not hex_str.startswith("0x") and not hex_str.startswith("0X"):
+        raise ValueError("truncate_hex_str: hex_str must start with 0x")
+    if digits <= 0:
+        raise ValueError("truncate_hex_str: digits must be more than zero")
+    hex_str = hex_str.removeprefix("0x").removeprefix("0X")
+    if digits * 2 >= len(hex_str):
+        raise ValueError("truncate_hex_str: digits is too large")
+    return "0x" + hex_str[:digits] + replace_str + hex_str[-1 * digits :]
+
+
+def log_topic_to_address(topic: HexBytes | str) -> str:
+    if isinstance(topic, HexBytes):
+        result = topic.hex()[-40:]
+    else:
+        result = topic[-40:]
+    if not result.startswith("0x"):
+        result = f"0x{result}"
+    return result
+
+
+def get_w3(rpc_url: str, timeout: int | None = None, proxy: str | None = None) -> Web3:
+    request_kwargs: dict[str, object] = {"timeout": timeout}
+    if proxy:
+        request_kwargs["proxies"] = {"http": proxy, "https": proxy}
+    return Web3(Web3.HTTPProvider(rpc_url, request_kwargs=request_kwargs))
+
+
+def name_network(chain_id: int) -> str:
+    match chain_id:
+        case 1:
+            return "Ethereum Mainnet"
+        case 5:
+            return "Goerli"
+        case 10:
+            return "OP Mainnet"
+        case 280:
+            return "zkSync Era Testnet"
+        case 324:
+            return "zkSync Era Mainnet"
+        case 420:
+            return "Optimism Goerli Testnet"
+        case 42161:
+            return "Arbitrum One"
+        case 43113:
+            return "Avalanche Fuji Testnet"
+        case 43114:
+            return "Avalanche C-Chain"
+        case 421613:
+            return "Arbitrum Goerli"
+        case _:
+            return ""
+
+
+def hex_str_to_int(value: str) -> Result[int]:
+    try:
+        return Ok(int(value, 16))
+    except Exception:
+        return Err(f"can't convert to int: {value}")
+
+
+def random_node(nodes: Nodes, remove_slash: bool = True) -> str:
+    node = cast(str, random_choice(nodes))
+    if remove_slash and node.endswith("/"):
+        node = node.removesuffix("/")
+    return node
+
+
+def random_proxy(proxies: Proxies) -> str | None:
+    return random_str_choice(proxies)

mm_eth/vault.py

@@ -0,0 +1,38 @@
+from mm_std import Err, Ok, Result, hr
+
+from mm_eth.account import private_to_address
+
+
+def read_keys_from_vault(keys_url: str, token: str) -> Result[dict[str, str]]:
+    data = None
+    try:
+        # keys_url example, https://vault.site.com:8200/v1/kv/keys1
+        res = hr(keys_url, headers={"X-Vault-Token": token})
+        data = res.json
+        return Ok(res.json["data"], data=data)
+    except Exception as e:
+        return Err(f"exception: {e}", data=data)
+
+
+def set_keys_from_vault(keys_url: str, token: str, private_keys: list[str], verify_tls: bool = True) -> Result[bool]:
+    """It works with KV version=1 only!!!"""  # TODO: check that keys_url is kv1 version and error if it's kv2
+    data = None
+    try:
+        # keys_url example, https://vault.site.com:8200/v1/kv/keys1
+        keys: dict[str, str] = {}
+        for private_key in private_keys:
+            address = private_to_address(private_key)
+            if address is None:
+                raise ValueError("there is a wrong private key")
+            keys[address] = private_key
+
+        res = hr(keys_url, method="post", headers={"X-Vault-Token": token}, params=keys, verify=verify_tls)
+        data = res.json
+        if res.code == 204:
+            return Ok(res.code == 204, data=data)
+        elif res.code == 403:
+            return Err("permission denied", data=data)
+        else:
+            return Err(res.error or "error", data=data)
+    except Exception as e:
+        return Err(f"exception: {e}", data=data)

mm_eth/zksync.py

@@ -0,0 +1,203 @@
+import json
+import pkgutil
+from typing import cast
+
+from eth_typing import ChecksumAddress, HexStr
+from hexbytes import HexBytes
+from mm_std import Err, Ok, Result
+from pydantic import BaseModel, Field
+from web3 import Web3
+from web3.types import ABI, Nonce, TxParams, Wei
+
+from mm_eth import abi, rpc
+from mm_eth.rpc import rpc_call
+from mm_eth.types import Nodes, Proxies
+from mm_eth.utils import hex_str_to_int
+
+L2_ETH_TOKEN_ADDRESS = Web3.to_checksum_address("0x000000000000000000000000000000000000800a")
+
+
+class BridgeContracts(BaseModel):
+    l1_erc20_Default_bridge: str = Field(..., alias="l1Erc20DefaultBridge")
+    l2_erc20_Default_bridge: str = Field(..., alias="l2Erc20DefaultBridge")
+
+
+def zks_get_bridge_contracts(
+    rpc_urls: Nodes,
+    timeout: int = 10,
+    proxies: Proxies = None,
+    attempts: int = 1,
+) -> Result[BridgeContracts]:
+    res = rpc_call(
+        nodes=rpc_urls,
+        method="zks_getBridgeContracts",
+        params=[],
+        timeout=timeout,
+        proxies=proxies,
+        attempts=attempts,
+    )
+    if isinstance(res, Err):
+        return res
+
+    try:
+        return Ok(BridgeContracts(**res.ok), data=res.data)
+    except Exception as e:
+        return Err(f"exception: {e}", data=res.data)
+
+
+def zks_get_main_contract(
+    rpc_urls: Nodes,
+    timeout: int = 10,
+    proxies: Proxies = None,
+    attempts: int = 1,
+) -> Result[str]:
+    return rpc_call(
+        nodes=rpc_urls,
+        method="zks_getMainContract",
+        params=[],
+        timeout=timeout,
+        proxies=proxies,
+        attempts=attempts,
+    )
+
+
+def zks_estimate_gas_l1_to_l2(
+    rpc_urls: Nodes,
+    timeout: int = 10,
+    proxies: Proxies = None,
+    attempts: int = 1,
+) -> Result[int]:
+    return rpc_call(
+        nodes=rpc_urls,
+        method="zks_estimateGasL1ToL2",
+        params=[
+            [
+                {
+                    "from": "0x1111111111111111111111111111111111111111",
+                    "to": "0x2222222222222222222222222222222222222222",
+                    "data": "0xffffffff",
+                },
+            ],
+        ],
+        timeout=timeout,
+        proxies=proxies,
+        attempts=attempts,
+    ).and_then(hex_str_to_int)
+
+
+def zksync_contract_abi() -> ABI:
+    data = pkgutil.get_data(__name__, "abi/zksync.json")
+    if data is None:
+        raise RuntimeError("can't read abi/zksync.json")
+    return cast(ABI, json.loads(data.decode()))
+
+
+def get_l2_transactio_base_cost(
+    eth_rpc: str,
+    contract_address: ChecksumAddress,
+    gas_price: Wei,
+    l2_gas_limit: int = 10000000,
+    l2_gas_per_pubdata_byte_limit: int = 800,
+) -> Result[Wei]:
+    w3 = Web3(Web3.HTTPProvider(eth_rpc))
+    try:
+        contract = w3.eth.contract(address=contract_address, abi=zksync_contract_abi())
+        res = contract.functions.l2TransactionBaseCost(gas_price, l2_gas_limit, l2_gas_per_pubdata_byte_limit).call()
+        return Ok(Wei(res))
+    except Exception as e:
+        return Err(str(e))
+
+
+def deposit(
+    *,
+    eth_rpc: str,
+    contract_address: ChecksumAddress,
+    wallet_address: ChecksumAddress,
+    private_key: str,
+    gas_price: Wei,
+    value: Wei,
+    l2_gas_limit: int = 1_300_000,
+    l2_gas_per_pubdata_byte_limit: int = 800,
+    gas: int = 150096,
+    nonce: Nonce | None = None,
+) -> Result[str]:
+    w3 = Web3(Web3.HTTPProvider(eth_rpc))
+    try:
+        # get nonce
+        if nonce is None:
+            res_nonce = rpc.eth_get_transaction_count(eth_rpc, wallet_address)
+            if isinstance(res_nonce, Err):
+                return res_nonce
+
+            nonce = Nonce(res_nonce.ok)
+
+        # get base_cost
+        res = get_l2_transactio_base_cost(eth_rpc, contract_address, gas_price, l2_gas_limit, l2_gas_per_pubdata_byte_limit)
+        if isinstance(res, Err):
+            return res
+        base_cost = Wei(res.ok)
+
+        contract_address_l2 = wallet_address
+        l2_value = value
+        calldata = b""
+        factory_deps = []  # type: ignore[var-annotated]
+        refund_recipient = wallet_address
+
+        contract = w3.eth.contract(address=contract_address, abi=zksync_contract_abi())
+        function_call = contract.functions.requestL2Transaction(
+            contract_address_l2,
+            l2_value,
+            calldata,
+            l2_gas_limit,
+            l2_gas_per_pubdata_byte_limit,
+            factory_deps,
+            refund_recipient,
+        )
+
+        transaction_data = function_call.build_transaction(
+            {"from": wallet_address, "gas": gas, "gasPrice": gas_price, "nonce": nonce, "value": Wei(value + base_cost)},
+        )
+        signed_transaction = w3.eth.account.sign_transaction(transaction_data, private_key)
+        txn = w3.eth.send_raw_transaction(signed_transaction.rawTransaction)
+        return Ok(str(txn))
+    except Exception as e:
+        return Err(f"exception: {e}")
+
+
+def withdraw(
+    *,
+    zksync_rpc: str,
+    wallet_address: ChecksumAddress,
+    private_key: str,
+    value: Wei,
+    chain_id: int,
+) -> Result[HexBytes]:
+    try:
+        w3 = Web3(Web3.HTTPProvider(zksync_rpc))
+
+        # get nonce
+        nonce = w3.eth.get_transaction_count(wallet_address)
+
+        input_data = abi.encode_function_signature("withdraw(address)") + abi.encode_data(
+            ["address"],
+            [wallet_address],
+        ).removeprefix("0x")
+
+        transaction_data: TxParams = {
+            "from": wallet_address,
+            "to": L2_ETH_TOKEN_ADDRESS,
+            "nonce": nonce,
+            "data": HexStr(input_data),
+            "value": value,
+            "chainId": chain_id,
+        }
+        gas = w3.eth.estimate_gas(transaction_data)
+        transaction_data["gas"] = gas
+        gas_price = w3.eth.gas_price
+        transaction_data["gasPrice"] = gas_price
+        signed_transaction = w3.eth.account.sign_transaction(transaction_data, private_key)
+        txn = w3.eth.send_raw_transaction(signed_transaction.rawTransaction)
+        return Ok(txn)
+
+    except Exception as e:
+        return Err(f"exception: {e}")

mm_eth-0.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: mm-eth
+Version: 0.1.0
+Requires-Python: >=3.12
+Requires-Dist: mm-std ~=0.1.0
+Requires-Dist: websocket-client ~=1.8.0
+Requires-Dist: web3 ~=6.20.0
+Requires-Dist: typer ~=0.12.0
+Requires-Dist: loguru ~=0.7.2
+Provides-Extra: dev
+Requires-Dist: build ~=1.2.1 ; extra == 'dev'
+Requires-Dist: twine ~=5.1.0 ; extra == 'dev'
+Requires-Dist: pytest ~=8.3.2 ; extra == 'dev'
+Requires-Dist: pytest-xdist ~=3.6.1 ; extra == 'dev'
+Requires-Dist: pytest-httpserver ~=1.0.8 ; extra == 'dev'
+Requires-Dist: coverage ~=7.6.0 ; extra == 'dev'
+Requires-Dist: ruff ~=0.5.2 ; extra == 'dev'
+Requires-Dist: pip-audit ~=2.7.0 ; extra == 'dev'
+Requires-Dist: bandit ~=1.7.7 ; extra == 'dev'
+Requires-Dist: mypy ~=1.11.0 ; extra == 'dev'
+Requires-Dist: types-python-dateutil ~=2.9.0 ; extra == 'dev'
+Requires-Dist: types-requests ~=2.32.0.20240523 ; extra == 'dev'
+Requires-Dist: types-PyYAML ~=6.0.12.12 ; extra == 'dev'
+

mm_eth-0.1.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+mm_eth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/abi.py,sha256=VpZETb7jh8Ovghxit-UI13cxAWP7siv5UqIzC70GIB0,4736
+mm_eth/account.py,sha256=ZpmcYRmJVa6oJMtSlLSkpjgbA8M-g6alaHQaeQT1I9Y,1982
+mm_eth/anvil.py,sha256=9CWXWyK7tVrvs6NeOy7QnVwMTrUke-nBMFwZeJ4VULA,1582
+mm_eth/deploy.py,sha256=SB3ruY808_5UnG8kHR34uVP66P3zOWZu0ImKD7UUv2s,691
+mm_eth/ens.py,sha256=WMxqC1v3zwDDuLH_oWekm22qrNYxCNcvZumQMT7SYds,623
+mm_eth/erc20.py,sha256=m62j00zizSZzXgLUEih2Q1iVFehU9qrqOMfc3gyix7k,6844
+mm_eth/ethernodes.py,sha256=9y_poTmFUj6cnWaT9mtfc6S9lAfVXTwLGRqxMQ8hT0Y,3080
+mm_eth/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/rpc.py,sha256=kQnYllp5ZHGuIUUX2Vw-ejLwL3zXQgka3ukwDndv4AM,13881
+mm_eth/solc.py,sha256=JcBCel-LO-lBvz3_1f7s3pVhECsUittavBvXqxYIP2c,1066
+mm_eth/tx.py,sha256=XkyafbEepG5VtJwVlM2NNPuFGit8pldKdOPh_R_1iJE,4032
+mm_eth/types.py,sha256=w_B1o_XggFz2cHXa36tI-wjfE4r-BFhvKIF9nb2YI5g,154
+mm_eth/utils.py,sha256=TMvQMtP7YyuBnv-bsjbcIzRfBUyVFBI8IjeolCXXlVg,7785
+mm_eth/vault.py,sha256=1ahABcgyYAMUlE4ELMGdlG_uV4irmwzrfzUZTpo3rdY,1500
+mm_eth/zksync.py,sha256=XLop9r5_gVEi9tm1MUfuSl0wUmbE27m7x0pir7T3hZA,5997
+mm_eth/abi/zksync.json,sha256=aHp6-Y5W6wRz0hrC0aPTjAHb-Q2ipDikcAB5FtlxWWA,45503
+mm_eth/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/calcs.py,sha256=nHfn_Q9T_E8_hP7ExMyWlUGvAMzxQs6KgzdNg1CUnvU,3651
+mm_eth/cli/cli.py,sha256=cxkSistUsdalp3xuOxgMYBp5u9jxnNitgv8Oc-AyVww,8768
+mm_eth/cli/cli_helpers.py,sha256=0NapwmrRVQ1PWDP6iqwaX1fnzrIdD_TwvcZXIcq5QzM,6572
+mm_eth/cli/cli_utils.py,sha256=4I12cJV0deKfarRpd2wNhW42L_jQab4oxa9DX-WxicM,5041
+mm_eth/cli/validators.py,sha256=bE4G-OL6W6S30P4FK5pVn_LiY2G2w8aeA3R1kQaX0gY,2379
+mm_eth/cli/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth/cli/cmd/balance_cmd.py,sha256=kDV_KAPrUY_fsGiVLcGGHspuU2zqpqsVnTe2btjtCxs,2254
+mm_eth/cli/cmd/balances_cmd.py,sha256=P3zyaJrghLXAYE7mnT3ReKnPYHiAqA7kZbkvLPioVUE,4326
+mm_eth/cli/cmd/call_contract_cmd.py,sha256=pKuWXZ6i4Taml_AnEJlffSsgjd_ktRoLDqmyAzwuDXk,1245
+mm_eth/cli/cmd/config_example_cmd.py,sha256=hMfrFxjIP0xZllJRRxi99qhF8tzJI3lrp-XudFEWF1g,270
+mm_eth/cli/cmd/deploy_cmd.py,sha256=MoPxZXNB_YlPh9qprA4EZ96Su-A2n_jeVJkhWVpsz1c,1258
+mm_eth/cli/cmd/encode_input_data_cmd.py,sha256=9UQ1MKPEFQJ8j_COsP3KGKhwOf9tT3feBezI8vvxTlw,267
+mm_eth/cli/cmd/mnemonic_cmd.py,sha256=BfcNSflEr5R8eINc1ATDc6w2pErfKfzL-Zloqbk3oio,1006
+mm_eth/cli/cmd/node_cmd.py,sha256=mUqixPGNHzuKCJvk1Fd5VaUGumpbR2AE7raGmXZscg4,1943
+mm_eth/cli/cmd/private_key_cmd.py,sha256=Fv_2OLog1h32pIP7PJITwl_pHdy3BXvaDRcXZsxY1xo,241
+mm_eth/cli/cmd/rpc_cmd.py,sha256=dCEbAF9bmJQq1pKf8JGcaIB-iorPz-tT4Tc7CweaEmY,2217
+mm_eth/cli/cmd/send_contract_cmd.py,sha256=xT1RVgIUvJIvEtvPxrqnCK0St5HoL022CXStxLEdriM,9047
+mm_eth/cli/cmd/solc_cmd.py,sha256=Xu6rdn15zQeHEEFpGxbD7ofojT_o6SVqg1dTpbock-Q,717
+mm_eth/cli/cmd/token_cmd.py,sha256=Sm4PiAABwnfgchBgj1VnmYrzF7oll8js9gKh6YNdwnE,1107
+mm_eth/cli/cmd/transfer_erc20_cmd.py,sha256=DA4Az9rINKDx7Pjrr4v9v-QNYpOc03TgnpaNEVGDVr4,10245
+mm_eth/cli/cmd/transfer_eth_cmd.py,sha256=dbXt2Ngb--RyA5HdvISwSlr129cd674GvGYLLuPaG3U,9429
+mm_eth/cli/cmd/vault_cmd.py,sha256=rRTclz0U6N_87KFsssdvZhi3_f6tmkHiYxMsIoVeBGc,532
+mm_eth/cli/config_examples/balances.yml,sha256=fpXJfoOSqOrkoWpqO7-HrTTb5OBs9PM-PpZ1ulqWUnY,399
+mm_eth/cli/config_examples/call_contract.yml,sha256=E0XuWuBnbhyTYfxNqaoxH6Cy7UCYqMLDwoEu_4OSV3M,233
+mm_eth/cli/config_examples/transfer_erc20.yml,sha256=mCUpUfqzZjTvst8kqd3EGzJY0S7cr48ySqS6yZhzLdI,1324
+mm_eth/cli/config_examples/transfer_eth.yml,sha256=i4hh3-LTcpl7JsrSuuM6gDi23B5ZnCeEnaYazQO3bzQ,1181
+mm_eth/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_eth-0.1.0.dist-info/METADATA,sha256=QdbiQBGZqJ9j6C3lB4X4zX49ytobR1CkR-ThN6YFUMw,925
+mm_eth-0.1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+mm_eth-0.1.0.dist-info/entry_points.txt,sha256=aGhpsozl8NIrkuUcX5fSgURCcDhr3ShUdeTSIrJq4oc,46
+mm_eth-0.1.0.dist-info/top_level.txt,sha256=hNXi_YDQ5FI_Qn4MC4AX0KeWf8KMAcTIk7jsGhoRRMA,7
+mm_eth-0.1.0.dist-info/RECORD,,

mm_eth-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mm_eth-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mm-eth = mm_eth.cli.cli:app

mm_eth-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mm_eth