Your Algorithm → Web3 Library (ethers.js / web3.py)
       ↓
Transaction Builder → Gas Estimation → MEV Protection
       ↓
RPC Node → Mempool → Block Inclusion
       ↓
DEX Smart Contract (Uniswap, SushiSwap, etc.)

from web3 import Web3
from eth_account import Account
import json
import os

# Use a private RPC for MEV protection
w3 = Web3(Web3.HTTPProvider(
    os.getenv('ETH_RPC_URL', 'https://ethereum-rpc.publicnode.com')
))

# Load your wallet (NEVER hardcode private keys)
account = Account.from_key(os.getenv('PRIVATE_KEY'))

# Uniswap V3 Router
ROUTER_ADDRESS = '0xE592427A0AEce92De3Edee1F18E0157C05861564'
with open('uniswap_v3_router_abi.json') as f:
    router_abi = json.load(f)
router = w3.eth.contract(
    address=ROUTER_ADDRESS, abi=router_abi
)

from datetime import datetime, timedelta

def execute_swap(
    token_in: str,
    token_out: str,
    amount_in: int,
    max_slippage_bps: int = 50,  # 0.5%
    deadline_minutes: int = 5,
) -> str:
    """Execute a swap on Uniswap V3 with slippage protection."""

    # Get expected output (simplified - use Quoter in production)
    # amount_out_min accounts for slippage
    amount_out_min = int(
        amount_in * (10000 - max_slippage_bps) / 10000
    )

    deadline = int(
        (datetime.now() + timedelta(minutes=deadline_minutes))
        .timestamp()
    )

    # Build the swap transaction
    swap_params = {
        'tokenIn': token_in,
        'tokenOut': token_out,
        'fee': 3000,  # 0.3% pool
        'recipient': account.address,
        'deadline': deadline,
        'amountIn': amount_in,
        'amountOutMinimum': amount_out_min,
        'sqrtPriceLimitX96': 0,  # No price limit
    }

    tx = router.functions.exactInputSingle(
        swap_params
    ).build_transaction({
        'from': account.address,
        'gas': 300000,
        'maxFeePerGas': w3.eth.gas_price * 2,
        'maxPriorityFeePerGas': w3.to_wei(2, 'gwei'),
        'nonce': w3.eth.get_transaction_count(account.address),
        'chainId': 1,
    })

    # Sign and send
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(
        signed.raw_transaction
    )

    # Wait for confirmation
    receipt = w3.eth.wait_for_transaction_receipt(
        tx_hash, timeout=120
    )

    if receipt['status'] == 1:
        print(f"Swap successful: {tx_hash.hex()}")
    else:
        print(f"Swap reverted: {tx_hash.hex()}")

    return tx_hash.hex()

# 1. Use a private mempool (Flashbots)
from flashbots import flashbot

flashbot(w3, account)

# 2. Set tight slippage (but not too tight)
max_slippage_bps = 30  # 0.3% - tight enough to limit MEV

# 3. Split large orders
def split_order(total_amount: int, num_chunks: int = 5):
    chunk_size = total_amount // num_chunks
    for i in range(num_chunks):
        amount = chunk_size if i < num_chunks - 1 \
                 else total_amount - chunk_size * (num_chunks - 1)
        execute_swap(TOKEN_IN, TOKEN_OUT, amount)
        time.sleep(12)  # Wait 1 block between chunks