mm-eth 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

mm_eth/cli/cmd/transfer_eth_cmd.py

@@ -1,252 +0,0 @@
-import time
-from pathlib import Path
-from typing import Self
-
-from loguru import logger
-from mm_std import Err, Ok, print_json, str_to_list, utc_now
-from pydantic import Field, StrictStr, field_validator, model_validator
-
-from mm_eth import rpc
-from mm_eth.account import create_private_keys_dict, private_to_address
-from mm_eth.cli import calcs, cli_helpers, cli_utils, validators
-from mm_eth.cli.cli_helpers import get_version
-from mm_eth.cli.cli_utils import BaseConfig
-from mm_eth.tx import sign_tx
-from mm_eth.utils import from_wei_str
-
-
-class Config(BaseConfig):
-    class Tx(BaseConfig):
-        from_address: str
-        to_address: str
-
-    nodes: list[StrictStr]
-    chain_id: int
-    private_keys: dict[str, str] = Field(default_factory=dict)
-    private_keys_file: str | None = None
-    max_fee_per_gas: str
-    max_fee_per_gas_limit: str | None = None
-    max_priority_fee_per_gas: str
-    value: str
-    value_min_limit: str | None = None
-    gas: str
-    addresses_map: str | None = None
-    addresses_from_file: str | None = None
-    addresses_to_file: str | None = None
-    delay: str | None = None  # in seconds
-    round_ndigits: int = 5
-    log_debug: str | None = None
-    log_info: str | None = None
-    txs: list[Tx] = Field(default_factory=list)
-
-    @property
-    def from_addresses(self) -> list[str]:
-        return [tx.from_address for tx in self.txs]
-
-    @field_validator("log_debug", "log_info", mode="before")
-    def log_validator(cls, v: str | None) -> str | None:
-        return validators.log_validator(v)
-
-    @field_validator("nodes", mode="before")
-    def nodes_validator(cls, v: str | list[str] | None) -> list[str]:
-        return validators.nodes_validator(v)
-
-    @field_validator("private_keys", mode="before")
-    def private_keys_validator(cls, v: str | list[str] | None) -> dict[str, str]:
-        if v is None:
-            return {}
-        if isinstance(v, str):
-            return create_private_keys_dict(str_to_list(v, unique=True, remove_comments=True))
-        return create_private_keys_dict(v)
-
-    # noinspection DuplicatedCode
-    @model_validator(mode="after")
-    def final_validator(self) -> Self:
-        # load private keys from file
-        if self.private_keys_file:
-            file = Path(self.private_keys_file).expanduser()
-            if not file.is_file():
-                raise ValueError("can't read private_keys_file")
-            for line in file.read_text().strip().split("\n"):
-                line = line.strip()
-                address = private_to_address(line)
-                if address is None:
-                    raise ValueError("there is not a private key in private_keys_file")
-                self.private_keys[address.lower()] = line
-
-        # max_fee_per_gas
-        if not validators.is_valid_calc_var_wei_value(self.max_fee_per_gas, "base"):
-            raise ValueError(f"wrong max_fee_per_gas: {self.max_fee_per_gas}")
-
-        # max_fee_per_gas_limit
-        if not validators.is_valid_calc_var_wei_value(self.max_fee_per_gas_limit, "base"):
-            raise ValueError(f"wrong max_fee_per_gas_limit: {self.max_fee_per_gas_limit}")
-
-        # max_priority_fee_per_gas
-        if not validators.is_valid_calc_var_wei_value(self.max_priority_fee_per_gas):
-            raise ValueError(f"wrong max_priority_fee_per_gas: {self.max_priority_fee_per_gas}")
-
-        # value
-        if not validators.is_valid_calc_var_wei_value(self.value, "balance"):
-            raise ValueError(f"wrong value: {self.value}")
-
-        # value_min_limit
-        if not validators.is_valid_calc_var_wei_value(self.value_min_limit):
-            raise ValueError(f"wrong value_min_limit: {self.value_min_limit}")
-
-        # gas
-        if not validators.is_valid_calc_var_wei_value(self.gas, "estimate"):
-            raise ValueError(f"wrong gas: {self.gas}")
-
-        # delay
-        if not validators.is_valid_calc_decimal_value(self.delay):
-            raise ValueError(f"wrong delay: {self.delay}")
-
-        # txs
-        if self.addresses_map:
-            for tx in cli_utils.load_tx_addresses_from_str(self.addresses_map):
-                self.txs.append(Config.Tx(from_address=tx[0], to_address=tx[1]))
-        if self.addresses_from_file and self.addresses_to_file:
-            self.txs.extend(
-                Config.Tx(from_address=tx[0], to_address=tx[1])
-                for tx in cli_utils.load_tx_addresses_from_files(self.addresses_from_file, self.addresses_to_file)
-            )
-        if not self.txs:
-            raise ValueError("txs is empty")
-
-        return self
-
-
-def run(
-    config_path: str,
-    *,
-    print_balances: bool,
-    print_config: bool,
-    debug: bool,
-    no_receipt: bool,
-    emulate: bool,
-) -> None:
-    config = cli_utils.read_config(Config, config_path)
-    if print_config:
-        print_json(config.model_dump(exclude={"private_keys", "addresses_map"}))
-        exit(0)
-
-    cli_utils.init_logger(debug, config.log_debug, config.log_info)
-    cli_utils.check_nodes_for_chain_id(config.nodes, config.chain_id)
-
-    if print_balances:
-        cli_helpers.print_balances(config.nodes, config.from_addresses, round_ndigits=config.round_ndigits)
-        exit(0)
-
-    return _run_transfers(config, no_receipt=no_receipt, emulate=emulate)
-
-
-# noinspection DuplicatedCode
-def _run_transfers(config: Config, *, no_receipt: bool, emulate: bool) -> None:
-    logger.info(f"started at {utc_now()} UTC")
-    logger.debug(f"config={config.model_dump(exclude={'private_keys', 'addresses_map'}) | {'version': get_version()} }")
-    cli_utils.check_private_keys(config.from_addresses, config.private_keys)
-    for i, tx in enumerate(config.txs):
-        _transfer(from_address=tx.from_address, to_address=tx.to_address, config=config, no_receipt=no_receipt, emulate=emulate)
-        if not emulate and config.delay is not None and i < len(config.txs) - 1:
-            delay_value = calcs.calc_decimal_value(config.delay)
-            logger.debug(f"delay {delay_value} seconds")
-            time.sleep(float(delay_value))
-    logger.info(f"finished at {utc_now()} UTC")
-
-
-# noinspection DuplicatedCode
-def _transfer(*, from_address: str, to_address: str, config: Config, no_receipt: bool, emulate: bool) -> None:
-    log_prefix = f"{from_address}->{to_address}"
-    # get nonce
-    nonce = cli_helpers.get_nonce(config.nodes, from_address, log_prefix)
-    if nonce is None:
-        return
-
-    # get max_fee_per_gas
-    max_fee_per_gas = cli_helpers.calc_max_fee_per_gas(config.nodes, config.max_fee_per_gas, log_prefix)
-    if max_fee_per_gas is None:
-        return
-
-    # check max_fee_per_gas_limit
-    if cli_helpers.is_max_fee_per_gas_limit_exceeded(max_fee_per_gas, config.max_fee_per_gas_limit, log_prefix):
-        return
-
-    # get gas
-    gas = cli_helpers.calc_gas(
-        nodes=config.nodes,
-        gas=config.gas,
-        from_address=from_address,
-        to_address=to_address,
-        value=123,
-        log_prefix=log_prefix,
-    )
-    if gas is None:
-        return
-
-    # get value
-    value = cli_helpers.calc_eth_value(
-        nodes=config.nodes,
-        value_str=config.value,
-        address=from_address,
-        gas=gas,
-        max_fee_per_gas=max_fee_per_gas,
-        log_prefix=log_prefix,
-    )
-    if value is None:
-        return
-
-    # value_min_limit
-    if cli_helpers.is_value_less_min_limit(config.value_min_limit, value, "eth", log_prefix=log_prefix):
-        return
-
-    max_priority_fee_per_gas = calcs.calc_var_wei_value(config.max_priority_fee_per_gas)
-    tx_params = {
-        "nonce": nonce,
-        "max_fee_per_gas": max_fee_per_gas,
-        "max_priority_fee_per_gas": max_priority_fee_per_gas,
-        "gas": gas,
-        "value": value,
-        "to": to_address,
-        "chain_id": config.chain_id,
-    }
-
-    # emulate?
-    if emulate:
-        msg = f"{log_prefix}: emulate, value={from_wei_str(value, 'eth', config.round_ndigits)},"
-        msg += f" max_fee_per_gas={from_wei_str(max_fee_per_gas, 'gwei', config.round_ndigits)},"
-        msg += f" max_priority_fee_per_gas={from_wei_str(max_priority_fee_per_gas, 'gwei', config.round_ndigits)},"
-        msg += f" gas={gas}"
-        logger.info(msg)
-        return
-
-    logger.debug(f"{log_prefix}: tx_params={tx_params}")
-    signed_tx = sign_tx(
-        nonce=nonce,
-        max_fee_per_gas=max_fee_per_gas,
-        max_priority_fee_per_gas=max_priority_fee_per_gas,
-        gas=gas,
-        private_key=config.private_keys[from_address],
-        chain_id=config.chain_id,
-        value=value,
-        to=to_address,
-    )
-    res = rpc.eth_send_raw_transaction(config.nodes, signed_tx.raw_tx, attempts=5)
-    if isinstance(res, Err):
-        logger.info(f"{log_prefix}: send_error: {res.err}")
-        return
-    tx_hash = res.ok
-
-    if no_receipt:
-        msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 'ether', round_ndigits=config.round_ndigits)}"
-        logger.info(msg)
-    else:
-        logger.debug(f"{log_prefix}: tx_hash={tx_hash}, wait receipt")
-        while True:
-            receipt_res = rpc.get_tx_status(config.nodes, tx_hash)
-            if isinstance(receipt_res, Ok):
-                status = "OK" if receipt_res.ok == 1 else "FAIL"
-                msg = f"{log_prefix}: tx_hash={tx_hash}, value={from_wei_str(value, 'ether', round_ndigits=config.round_ndigits)}, status={status}"  # noqa
-                logger.info(msg)
-                break
-            time.sleep(1)

mm_eth/cli/cmd/vault_cmd.py

@@ -1,16 +0,0 @@
-from mm_std import fatal, print_plain
-
-from mm_eth import vault
-from mm_eth.cli import cli_utils
-
-
-def run(keys_url: str, vault_token: str, keys_file: str) -> None:
-    private_keys = cli_utils.load_private_keys_from_file(keys_file)
-    if not private_keys:
-        fatal("private keys not found")
-
-    res = vault.set_keys_from_vault(keys_url, vault_token, private_keys)
-    if res.is_ok() and res.ok is True:
-        print_plain(f"saved {len(private_keys)} private keys to the vault")
-    else:
-        fatal(f"error: {res.err}")

mm_eth/cli/config_examples/balances.yml

@@ -1,15 +0,0 @@
-addresses: |
-  0x10fd602Bff689e64D4720D1DCCCD3494f1f16623
-  0x58487485c3858109f5A37e42546FE87473f79a4b
-  0x97C77B548aE0d4925F5C201220fC6d8996424309
-
-tokens: |
-  0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # USDT
-  0x6a55fe4884DE7E1d904BdC47A3BA092240ae9B39 # USDC
-
-nodes: |
-  https://arb1.arbitrum.io/rpc
-  https://rpc.arb1.arbitrum.gateway.fm
-  https://arbitrum-one.publicnode.com
-
-round_ndigits: 3

mm_eth/cli/config_examples/call_contract.yml

@@ -1,5 +0,0 @@
-contract_address: "0xBa985cad26658EB00eA42aCc7516aed52e7a8AcC"
-function_signature: balanceOf(address)
-function_args: "['0x83aC43147BA5dAA5abc4ccEA84F2B8000bA82f26']"
-outputs_types: uint256 # optional
-node: https://rpc.eth.gateway.fm

mm_eth/cli/config_examples/transfer_erc20.yml

@@ -1,26 +0,0 @@
-token: "0x60631C856303731BE4deb81C0303F80B652aA5b4" # USDC
-decimals: 6
-max_fee_per_gas: 1.2base + 1gwei + random(1,200) # supported var_name=base
-max_fee_per_gas_limit: 10.1gwei - random(1,10) # optional
-max_priority_fee_per_gas: 1gwei + random(1,12)
-gas: estimate + random(100,200) - 19 # supported var_name=estimate
-value: 0.5balance - random(1.5t,3t) + 11gwei # supported var_name=balance
-value_min_limit: 0.5t + random(1,2) - 7
-addresses_map: |
-  0x10fd602Bff689e64D4720D1DCCCD3494f1f16623 0x58487485c3858109f5A37e42546FE87473f79a4b
-  0x97C77B548aE0d4925F5C201220fC6d8996424309 0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # can comment here
-  # and here
-addresses_from_file: ~/path/from.txt
-addresses_to_file: ~/path/to.txt
-delay: random(1.123,10) + 1 # secs, optional
-private_keys: | # optional, private_keys or private_keys_file must be used
-  0x7bb5b9c0ba991275f84b796b4d25fd3a8d7320911f50fade85410e7a2b000632
-  0xb7e0b671e176b04ceb0897a698d34771bfe9acf29273dc52a141be6e97145a00
-private_keys_file: ~/path/private_keys.txt # optional, private_keys or private_keys_file must be used
-log_debug: /path/to/file_debug.log # optional
-log_info: /path/to/file_info.log # optional
-round_ndigits: 6 # optional, default=5
-chain_id: 421613
-nodes: |
-  https://arbitrum-goerli.publicnode.com
-  https://rpc.goerli.arbitrum.gateway.fm

mm_eth/cli/config_examples/transfer_eth.yml

@@ -1,24 +0,0 @@
-max_fee_per_gas: 1.2base + 1gwei + random(1,200) # supported var_name=base
-max_fee_per_gas_limit: 10.1gwei - random(1,10) # optional
-max_priority_fee_per_gas: 1gwei + random(1,12)
-gas: estimate + random(100,200) - 19 # supported var_name=estimate
-value: balance - random(0.002eth,0.0025eth) + 11gwei # supported var_name=balance. If 'balance' is used, value=calc(value) - gas*max_fee_per_gas
-value_min_limit: 0.001eth + random(1,2) - 7
-addresses_map: |
-  0x10fd602Bff689e64D4720D1DCCCD3494f1f16623 0x58487485c3858109f5A37e42546FE87473f79a4b
-  0x97C77B548aE0d4925F5C201220fC6d8996424309 0x7EdF3b8579c21A8820b4C0B8352541c1CE04045f # can comment here
-  # and here
-#addresses_from_file: ~/path/from.txt
-#addresses_to_file: ~/path/to.txt
-delay: random(1.123,10) + 1 # secs
-#private_keys: |
-# 0x7bb5b9c0ba991275f84b796b4d25fd3a8d7320911f50fade85410e7a2b000632
-# 0xb7e0b671e176b04ceb0897a698d34771bfe9acf29273dc52a141be6e97145a00
-private_keys_file: ~/path/private_keys.txt
-log_debug: /path/to/file_debug.log # optional
-log_info: /path/to/file_info.log # optional
-round_ndigits: 6
-chain_id: 421613
-nodes: |
-  https://arbitrum-goerli.publicnode.com
-  https://rpc.goerli.arbitrum.gateway.fm

mm_eth/cli/validators.py

@@ -1,84 +0,0 @@
-import os
-from decimal import Decimal, InvalidOperation
-from pathlib import Path
-
-from mm_std import str_to_list
-
-from mm_eth.cli import calcs
-from mm_eth.utils import to_wei
-
-
-def wei_validator(v: str | None) -> int | None:
-    if v is None:
-        return None
-    return to_wei(v)
-
-
-def log_validator(v: str | None) -> str | None:
-    if v is None:
-        return None
-    log_file = Path(v).expanduser()
-    log_file.touch(exist_ok=True)
-    if not (log_file.is_file() and os.access(log_file, os.W_OK)):
-        raise ValueError(f"wrong log path: {v}")
-    return v
-
-
-def nodes_validator(v: str | list[str] | None) -> list[str]:
-    if v is None:
-        return []
-    if isinstance(v, str):
-        return str_to_list(v, unique=True, remove_comments=True, split_line=True)
-    return v
-
-
-def addresses_validator(v: str | list[str] | None) -> list[str]:
-    if v is None:
-        return []
-    if isinstance(v, str):
-        return str_to_list(v, unique=True, remove_comments=True, split_line=True, lower=True)
-    return v
-
-
-def delay_validator(v: str | Decimal) -> Decimal | tuple[Decimal, Decimal]:
-    if isinstance(v, int | float):
-        return Decimal(str(v))
-    elif isinstance(v, str):
-        arr = [a.strip() for a in v.split("-")]
-        if len(arr) != 2:
-            raise ValueError("wrong delay value")
-        try:
-            return Decimal(arr[0]), Decimal(arr[1])
-        except InvalidOperation:
-            raise ValueError("wrong delay value") from None
-    raise ValueError("wrong delay value")
-
-
-def is_valid_calc_var_wei_value(value: str | None, base_name: str = "var", decimals: int | None = None) -> bool:
-    if value is None:
-        return True  # check for None on BaseModel.field type level
-    try:
-        calcs.calc_var_wei_value(value, var_value=123, var_name=base_name, decimals=decimals)
-        return True
-    except ValueError:
-        return False
-
-
-def is_valid_calc_decimal_value(value: str | None) -> bool:
-    if value is None:
-        return True  # check for None on BaseModel.field type level
-    try:
-        calcs.calc_decimal_value(value)
-        return True
-    except ValueError:
-        return False
-
-
-def is_valid_calc_function_args(value: str | None) -> bool:
-    if value is None:
-        return True
-    try:
-        calcs.calc_function_args(value)
-        return True
-    except ValueError:
-        return False

mm_eth/zksync.py

@@ -1,203 +0,0 @@
-import json
-import pkgutil
-from typing import cast
-
-from eth_typing import ABI, 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 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.4.dist-info/METADATA

@@ -1,9 +0,0 @@
-Metadata-Version: 2.3
-Name: mm-eth
-Version: 0.1.4
-Requires-Python: >=3.12
-Requires-Dist: loguru~=0.7.2
-Requires-Dist: mm-std~=0.1.6
-Requires-Dist: typer>=0.13.0
-Requires-Dist: web3~=7.5.0
-Requires-Dist: websocket-client~=1.8.0