Python

Python's OP Mainnet tooling splits cleanly by job: web3.py handles general scripting and application code — reading balances, signing ETH transfers, calling contracts on chain ID 10 — while eth-brownie wraps a full smart-contract development workflow with testing and deployment built in. Because OP Mainnet is EVM-equivalent, both libraries work against it exactly as they do on Ethereum L1, scaling from a five-line balance script up to a complex production backend.

web3.py 6+ offers both a synchronous and an async interface, so you can keep simple OP Mainnet scripts blocking and straightforward while still scaling concurrent workloads when you need them. The async path requires AsyncWeb3 paired with an async-compatible provider — it is not just a flag on the regular client.

Web3.py

web3.py is the canonical Python library for OP Mainnet, exposing the full JSON-RPC API surface through a Pythonic interface. Install it with pip install web3, then connect by handing the endpoint to an HTTP provider: Web3(Web3.HTTPProvider('https://optimism.therpc.io/YOUR_API_KEY')). The resulting web3 object is your gateway to chain ID 10 — web3.eth.get_balance, web3.eth.gas_price, transaction submission, and everything else.

1from web3 import Web3
2from eth_account import Account
3import json
4 
5# Initialize web3
6web3 = Web3(Web3.HTTPProvider('https://optimism.therpc.io/YOUR_API_KEY'))
7 
8# Get balance
9def get_balance(address):
10    balance_wei = web3.eth.get_balance(address)
11    balance_eth = web3.from_wei(balance_wei, 'ether')
12    return balance_eth
13 
14# Send transaction
15def send_transaction(private_key, to_address, value_eth):
16    account = Account.from_key(private_key)
17    transaction = {
18        'nonce': web3.eth.get_transaction_count(account.address),
19        'to': to_address,
20        'value': web3.to_wei(value_eth, 'ether'),
21        'gas': 21000,
22        'gasPrice': web3.eth.gas_price
23    }
24    signed_txn = account.sign_transaction(transaction)
25    tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
26    return web3.eth.wait_for_transaction_receipt(tx_hash)

• GitHub: https://github.com/ethereum/web3.py
• Docs: https://web3py.readthedocs.io/
• Key features: full OP Mainnet JSON-RPC API, both sync and async interfaces, comprehensive type hints, a pluggable middleware stack, and ENS resolution

Eth-brownie

eth-brownie is a Python framework built around the smart-contract lifecycle on OP Mainnet — writing, testing, and deploying Solidity with a Python-native test runner and an interactive console. Install it with pip install eth-brownie, and point its network config at your OP Mainnet endpoint to compile, deploy, and exercise contracts against chain ID 10.

1from brownie import *
2 
3# Deploy contract
4def deploy_contract():
5    account = accounts[0]
6    return MyContract.deploy({'from': account})
7 
8# Interact with contract
9def interact_with_contract(contract_address):
10    contract = MyContract.at(contract_address)
11    return contract.myFunction({'from': accounts[0]})
12 
13# Test contract
14def test_contract(Contract):
15    account = accounts[0]
16    contract = account.deploy(Contract)
17    assert contract.myFunction() == expected_value

• GitHub: https://github.com/eth-brownie/brownie
• Docs: https://eth-brownie.readthedocs.io/
• Key features: a contract testing framework, deployment management, an interactive console, network management for OP Mainnet and other EVM chains, and a Python REPL for live debugging

Async Support

The async interface centers on AsyncWeb3, which lets you fire many OP Mainnet calls concurrently instead of waiting on each in turn — a big win when you are pulling a range of blocks or many account balances at once. It requires an async-compatible provider and runs inside an asyncio event loop, so structure your code with async def and await and drive it through asyncio.run.

1from web3.auto import w3
2import asyncio
3 
4async def get_latest_blocks(count):
5    latest = await w3.eth.get_block_number()
6    blocks = []
7    for i in range(count):
8        block = await w3.eth.get_block(latest - i)
9        blocks.append(block)
10    return blocks
11 
12# Usage
13blocks = asyncio.run(get_latest_blocks(10))

Type Hints

web3.py ships comprehensive type stubs, so you can annotate OP Mainnet code with TxParams, Wei, and Address imported from web3.types. Those annotations unlock IDE autocompletion and let mypy catch mistakes statically — for instance flagging a plain int passed where a Wei value is expected before it ever reaches the network.

1from web3.types import TxParams, Wei, Address
2from typing import Optional
3 
4def prepare_transaction(
5    to: Address,
6    value: Wei,
7    gas_price: Optional[Wei] = None
8) -> TxParams:
9    return {
10        'to': to,
11        'value': value,
12        'gasPrice': gas_price or web3.eth.gas_price
13    }