--config=gnosis
--datadir=/data
--log=INFO
--logger-config=/etc/nethermind/NLog.config
--Sync.SnapSync=true
--Sync.NetworkingEnabled=true
--JsonRpc.Enabled=true
--JsonRpc.Host=0.0.0.0
--JsonRpc.Port=8545
--JsonRpc.JwtSecretFile=/data/jwt.hex
--JsonRpc.EngineHost=0.0.0.0
--JsonRpc.EnginePort=8551
--Network.DiscoveryPort=30303
--Network.MaxActivePeers=20
--HealthChecks.Enabled=true
--Metrics.Enabled=true
--Metrics.ExposeHost=0.0.0.0
--Metrics.ExposePort=6060

import secrets
import sys
from datetime import datetime

from eth_account import Account
from web3 import Web3

rpc_node = "https://gnosis-node.localhost/"
SAFE_SINGLETON_ADDRESS = "0xd9Db270c1B5E3Bd161E8c8503c55cEABeE709552"
PROXY_FACTORY_ADDRESS = "0xa6B71E26C5e0845f74c812102Ca7114b6a896AB2"
FALLBACK_HANDLER_ADDRESS = "0xf48f2B2d2a534e402487b3ee7C18c33Aec0Fe5e4"
ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
PRIVATE_KEY = open("pk.txt").read().strip()
ACCOUNT = Account.from_key(PRIVATE_KEY)

# GnosisSafe setup function ABI
SAFE_SETUP_ABI = {
    "inputs": [
        {"internalType": "address[]", "name": "_owners", "type": "address[]"},
        {"internalType": "uint256", "name": "_threshold", "type": "uint256"},
        {"internalType": "address", "name": "to", "type": "address"},
        {"internalType": "bytes", "name": "data", "type": "bytes"},
        {"internalType": "address", "name": "fallbackHandler", "type": "address"},
        {"internalType": "address", "name": "paymentToken", "type": "address"},
        {"internalType": "uint256", "name": "payment", "type": "uint256"},
        {
            "internalType": "address payable",
            "name": "paymentReceiver",
            "type": "address",
        },
    ],
    "name": "setup",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function",
}

# GnosisSafeProxyFactory createProxyWithNonce function ABI
FACTORY_CREATE_PROXY_ABI = {
    "inputs": [
        {"internalType": "address", "name": "_singleton", "type": "address"},
        {"internalType": "bytes", "name": "initializer", "type": "bytes"},
        {"internalType": "uint256", "name": "saltNonce", "type": "uint256"},
    ],
    "name": "createProxyWithNonce",
    "outputs": [
        {"internalType": "contract GnosisSafeProxy", "name": "proxy", "type": "address"}
    ],
    "stateMutability": "nonpayable",
    "type": "function",
}


def get_estimation(rpc_url: str) -> int:
    web3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": 30}))
    safe_contract = web3.eth.contract(
        address=web3.to_checksum_address(SAFE_SINGLETON_ADDRESS),
        abi=[SAFE_SETUP_ABI],
    )
    factory_contract = web3.eth.contract(
        address=web3.to_checksum_address(PROXY_FACTORY_ADDRESS),
        abi=[FACTORY_CREATE_PROXY_ABI],
    )
    owner_address = web3.to_checksum_address(ACCOUNT.address)
    setup_call = safe_contract.functions.setup(
        [owner_address],
        1,
        web3.to_checksum_address(ZERO_ADDRESS),
        b"",
        web3.to_checksum_address(FALLBACK_HANDLER_ADDRESS),
        web3.to_checksum_address(ZERO_ADDRESS),
        0,
        web3.to_checksum_address(ZERO_ADDRESS),
    )
    initializer = setup_call._encode_transaction_data()
    salt_nonce = secrets.SystemRandom().randint(0, 2**256 - 1)
    return factory_contract.functions.createProxyWithNonce(
        web3.to_checksum_address(SAFE_SINGLETON_ADDRESS),
        initializer,
        salt_nonce,
    ).estimate_gas({"from": owner_address})


if __name__ == "__main__":
    for attempt in range(250):
        try:
            gas = get_estimation(rpc_node)
            prefix = f"[{datetime.now()}] Gnosis"
            print(f"{prefix} Gas Estimation (Attempt {attempt}): {gas}")
        except Exception as e:
            prefix = f"[{datetime.now()}] Gnosis"
            print(f"{prefix} Failed to estimate gas on attempt {attempt}: {e}")
            sys.exit(1)