def get_web3(network, sockets=False):
"""Get a Web3 session for the provided network.
Attributes:
network (str): The network to establish a session with.
Raises:
UnsupportedNetworkException: The exception is raised if the method
is passed an invalid network.
Returns:
web3.main.Web3: A web3 instance for the provided network.
"""
if network in ['mainnet', 'rinkeby', 'ropsten']:
if sockets:
if settings.INFURA_USE_V3:
provider = WebsocketProvider(f'wss://{network}.infura.io/ws/v3/{settings.INFURA_V3_PROJECT_ID}')
else:
provider = WebsocketProvider(f'wss://{network}.infura.io/ws')
else:
if settings.INFURA_USE_V3:
provider = HTTPProvider(f'https://{network}.infura.io/v3/{settings.INFURA_V3_PROJECT_ID}')
else:
provider = HTTPProvider(f'https://{network}.infura.io')
w3 = Web3(provider)
if network == 'rinkeby':
w3.middleware_stack.inject(geth_poa_middleware, layer=0)
return w3
elif network == 'localhost' or 'custom network':
return Web3(Web3.HTTPProvider("http://testrpc:8545", request_kwargs={'timeout': 60}))
raise UnsupportedNetworkException(network)
def get_web3_connection_provider(
network_url: str,
) -> Union[CustomHTTPProvider, WebsocketProvider]:
"""Return the suitable web3 provider based on the network_url.
Requires going through some gateway such as `infura`.
Using infura has some issues if your code is relying on evm events.
To use events with an infura connection you have to use the websocket interface.
Make sure the `infura` url for websocket connection has the following format
wss://rinkeby.infura.io/ws/v3/357f2fe737db4304bd2f7285c5602d0d
Note the `/ws/` in the middle and the `wss` protocol in the beginning.
:param network_url: str
:return: provider : Union[CustomHTTPProvider, WebsocketProvider]
"""
if network_url.startswith("http"):
return CustomHTTPProvider(network_url)
elif network_url.startswith("ws"):
return WebsocketProvider(network_url)
else:
msg = (
f"The given network_url *{network_url}* does not start with either"
f"`http` or `wss`. A correct network url is required."
)
raise AssertionError(msg)
def create_provider(config):
"""Create a web3.py provider
:param config: Provider configuration
:type config: dict
"""
provider, opts = config.get('ETHEREUM_PROVIDER',
ETHEREUM_PROVIDER), config.get(
'ETHEREUM_OPTS', ETHEREUM_OPTS)
if provider == 'http':
return HTTPProvider(endpoint_uri=config.get('ETHEREUM_ENDPOINT_URI',
ETHEREUM_ENDPOINT_URI),
**opts)
elif provider == 'ipc':
return IPCProvider(ipc_path=config.get('ETHEREUM_IPC_PATH',
ETHEREUM_IPC_PATH),
**opts)
elif provider == 'ws':
return WebsocketProvider(endpoint_uri=config.get(
'ETHEREUM_ENDPOINT_URI', ETHEREUM_ENDPOINT_URI),
**opts)
elif provider == 'test':
return EthereumTesterProvider()
else:
raise Exception(
"'ETHEREUM_PROVIDER' configuration must be one of 'http', 'ipc', 'ws', 'test'"
)
def __init__(self, app):
self.app = app
# Configure web3
if config.ETHEREUM_JSON_RPC_ENDPOINT.startswith("ws:"):
provider = WebsocketProvider(config.ETHEREUM_JSON_RPC_ENDPOINT)
else:
provider = HTTPProvider(config.ETHEREUM_JSON_RPC_ENDPOINT)
self.w3 = Web3(provider)
self.w3.eth.enable_unaudited_features() # Pending security audit, but required for offline signing of txns
# Setup agent contract
with open(Path(__file__).absolute().parent.joinpath("resources", "Agent.json")) as f:
abi = json.load(f)["abi"]
self.agent = self.w3.eth.contract(address=self.to_checksum_address(config.AGENT_CONTRACT_ADDRESS), abi=abi)
if config.PRIVATE_KEY and config.PRIVATE_KEY != "":
if config.PRIVATE_KEY.startswith("0x"):
self.private_key = bytes(bytearray.fromhex(config.PRIVATE_KEY[2:]))
else:
self.private_key = bytes(bytearray.fromhex(config.PRIVATE_KEY))
else:
# Derive key
master_key = bip32utils.BIP32Key.fromEntropy(Mnemonic("english").to_seed(config.HDWALLET_MNEMONIC))
purpose_subtree = master_key.ChildKey(44 + bip32utils.BIP32_HARDEN)
coin_type_subtree = purpose_subtree.ChildKey(60 + bip32utils.BIP32_HARDEN)
account_subtree = coin_type_subtree.ChildKey(bip32utils.BIP32_HARDEN)
change_subtree = account_subtree.ChildKey(0)
account = change_subtree.ChildKey(config.HDWALLET_INDEX)
self.private_key = account.PrivateKey()
public_key = ecdsa.SigningKey.from_string(string=self.private_key,
curve=ecdsa.SECP256k1,
hashfunc=hashlib.sha256).get_verifying_key()
self.address = self.to_checksum_address("0x" + self.w3.sha3(hexstr=public_key.to_string().hex())[12:].hex())
def create_provider(config):
"""Create a web3.py provider
:param config: Provider configuration (compatible with :meth:`consensys_utils.config.schema.web3.Web3ConfigSchema`)
:type config: dict
"""
provider, opts = config.get('ETHEREUM_PROVIDER'), config.get(
'ETHEREUM_OPTS', {})
if provider == 'http':
from web3 import HTTPProvider
return HTTPProvider(endpoint_uri=config.get('ETHEREUM_ENDPOINT_URI'),
**opts)
elif provider == 'ipc':
from web3 import IPCProvider
return IPCProvider(ipc_path=config.get('ETHEREUM_IPC_PATH'), **opts)
elif provider == 'ws':
from web3 import WebsocketProvider
return WebsocketProvider(
endpoint_uri=config.get('ETHEREUM_ENDPOINT_URI'), **opts)
elif provider == 'test':
from web3 import EthereumTesterProvider
return EthereumTesterProvider()
else:
raise RuntimeError(
"'ETHEREUM_PROVIDER' configuration must be one of 'http', 'ipc', 'ws', 'test'"
)
def __init__(self, address: str, privkey: str):
self._address = address
self._privkey = privkey
self._web3 = Web3(WebsocketProvider(endpoint_uri=URI(CLIENT_API_URL)))
checked_contract_address = self._web3.toChecksumAddress(CONTRACT_ADDRESS)
abi = loads(ABI)
self._contract = self._web3.eth.contract(abi=abi, address=checked_contract_address)
def test_make_contract(self):
web3 = Web3(WebsocketProvider(endpoint_uri="localhost:8545"))
contract = _make_contract(
web3, "0xA411eB36538a2Ae060A766221E43A94205460369", "Feed")
assert contract is not None
def __init__(
self,
contract_address,
contract_abi_string,
ethereum_chain_id,
http_provider,
websocket_provider,
gas_price_gwei,
gas_limit,
):
self.abi_dict = json.loads(contract_abi_string)
self.contract_address = utils.checksum_encode(contract_address)
self.ethereum_chain_id = int(ethereum_chain_id)
self.w3 = Web3(HTTPProvider(http_provider))
self.wsw3 = Web3(WebsocketProvider(websocket_provider))
self.contract = self.w3.eth.contract(address=self.contract_address,
abi=self.abi_dict)
self.decimals = self.get_decimals()
self.gas_price = self.w3.toWei(gas_price_gwei, 'gwei')
self.gas_limit = gas_limit
self.transaction_max_value = self.gas_price * self.gas_limit
def dial(self, target):
'''
connects to a node
:param url: string (optional) - resource in which to connect.
if not provided, will use default for the stage
:returns: provider, error
'''
if not target:
return None, "target network must be specified with -t or --target"
url = get_url(self.config, target)
try:
if url.startswith('ws'):
self.w3 = Web3(WebsocketProvider(url))
elif url.startswith('http'):
self.w3 = Web3(HTTPProvider(url))
elif url.endswith('ipc'):
if url == 'ipc':
url = None
self.w3 = Web3(Web3.IPCProvider(url))
else:
return None, "Invalid Provider URL: {}".format(url)
except Exception as e:
return None, e
return self.w3, None
def connect(self, node: str, timeout: int = 10) -> None:
try:
if os.path.exists(node):
self.provider = IPCProvider(node)
return
except OSError:
pass
if node.startswith("https://") or node.startswith("http://"):
self.provider = HTTPProvider(node,
request_kwargs={"timeout": timeout})
elif node.startswith("ws://") or node.startswith("wss://"):
self.provider = WebsocketProvider(
node, websocket_kwargs={"timeout": timeout})
else:
raise ValueError(
"The provided node is not valid. It must start with 'http://' or 'https://' or 'ws://' or a path to an IPC socket file."
)
try:
self.handleEnode()
except Exception:
pass
try:
self.handleProofOfAuthorityChain()
except Exception:
pass
def create_provider_from_config(rpc_config: MutableMapping):
uri = rpc_config.get("uri", None)
if uri is not None:
logger.info(f"Autodetect provider from uri {uri}")
provider = load_provider_from_uri(uri)
logger.info(f"Autodetected {provider.__class__.__name__}")
return provider
provider_type = rpc_config["type"]
if provider_type is ProviderType.HTTP:
url = "{}://{}:{}".format(
"https" if rpc_config["use_ssl"] else "http",
rpc_config["host"],
rpc_config["port"],
)
logger.info("Using HTTP provider with URL {}".format(url))
return HTTPProvider(URI(url))
elif provider_type is ProviderType.WEBSOCKET:
url = "{}://{}:{}".format(
"wss" if rpc_config["use_ssl"] else "ws",
rpc_config["host"],
rpc_config["port"],
)
logger.info("Using websocket provider with URL {}".format(url))
return WebsocketProvider(URI(url))
elif provider_type is ProviderType.IPC:
file_path = rpc_config["file_path"]
logger.info("Using IPC provider with file path {}".format(file_path))
return IPCProvider(file_path)
else:
raise ValueError(f"Unknown web3 provider type: {provider_type}")
def connect(self, uri: str, timeout: int = 30) -> None:
"""Connects to a provider"""
self._remove_middlewares()
self.provider = None
uri = _expand_environment_vars(uri)
try:
if Path(uri).exists():
self.provider = IPCProvider(uri, timeout=timeout)
except OSError:
pass
if self.provider is None:
if uri.startswith("ws"):
self.provider = WebsocketProvider(uri,
{"close_timeout": timeout})
elif uri.startswith("http"):
self.provider = HTTPProvider(uri, {"timeout": timeout})
else:
raise ValueError(
"Unknown URI - must be a path to an IPC socket, a websocket "
"beginning with 'ws' or a URL beginning with 'http'")
try:
if self.isConnected():
self.reset_middlewares()
except Exception:
# checking an invalid connection sometimes raises on windows systems
pass
def __init__(self, settings):
self.apiurl: str = settings["apiUrl"]
self.testmode = False
if "providerType" in settings:
pT = settings["providerType"]
if pT == "HTTPProvider":
self.provider: Web3 = Web3(
HTTPProvider(settings["providerUrl"]))
elif pT == "IPCProvider":
self.provider: Web3 = Web3(IPCProvider(
settings["providerUrl"]))
elif pT == "WebsocketProvider":
self.provider: Web3 = Web3(
WebsocketProvider(settings["providerUrl"]))
else:
self.provider: Web3 = Web3(HTTPProvider(settings["providerUrl"]))
if "mnemonicKey" in settings:
self.wallet: Account = Account.privateKeyToAccount(
mnemonic_to_private_key(settings["mnemonicKey"]))
if "privateKey" in settings:
self.wallet: Account = Account.privateKeyToAccount(
str(settings["privateKey"]))
self.blockchain: str = str(settings["blockchain"]).lower()
self.myaddress: str = self.wallet.address
self.query = RequestManager(self.apiurl, self.provider, self.wallet,
self.blockchain)
if "testMode" in settings:
if bool(settings["testMode"]) == True:
print("TEST MODE ENABLED, TRANSACTION WONT BE BROADCASTED")
self.testmode = True
# The following flag values default to False, to allow the simplest and best trading experience for most users.
# SBTKN False means TRADES ARE REQUESTED IN DECIMAL TOKEN UNITS. True means they are requested in integer subtoken units.
# BNDL False means WE DO NOT ALLOW BUNDLE PRICING ON NEW ORDERS, ONLY INTEGER PRICES. True means we allow Fraction prices.
# STRICT False means WE CREATE OR EXECUTE NEAREST VALID TRADE <= REQUESTED TRADE. True means invalid trades throw an error.
# These flags can and should be ignored and left out of function calls unless the user wants to change them.
self.SBTKN = False
self.STRICT = False
self.BNDL = False
self.DEBUG = False
if "SBTKN" in settings:
self.SBTKN = settings["SBTKN"]
if "STRICT" in settings:
self.STRICT = settings["STRICT"]
if "BNDL" in settings:
self.BNDL = settings["BNDL"]
if "DEBUG" in settings:
self.DEBUG = settings["DEBUG"]
self.exchange = ExchangeInterface(self.provider, self.wallet,
self.query, self.blockchain,
self.testmode, self.SBTKN,
self.STRICT, self.BNDL, self.DEBUG)
print("TRADING WALLET: " + self.myaddress)
def get_provider_for_filter(web3: Web3):
use_infura = False if "infura" not in web3.provider.endpoint_uri else True
if use_infura:
wss_url = f"wss://{'/ws/'.join(web3.provider.endpoint_uri.split('://')[1].split('/', 1))}"
return Web3(WebsocketProvider(wss_url))
else:
return web3
def __init__(self, http_provider_url=ETHEREUM_URL_WEB3_PROVIDER):
self.connection = Web3(
WebsocketProvider(http_provider_url, websocket_timeout=40))
if settings.APP_ENV == 'production' or settings.APP_ENV == 'testing' or settings.APP_ENV == 'development':
# for PoA and Rinkeby we have to add middleware
self.connection.middleware_stack.inject(geth_poa_middleware,
layer=0)
def get_provider(endpoint):
scheme = urlparse(endpoint).scheme
if scheme == 'ws' or scheme == 'wss':
return WebsocketProvider(endpoint)
if scheme == 'http' or scheme == 'https':
return HTTPProvider(endpoint)
raise Exception('Wrong endpoint option.'
'Supported endpoint schemes: http/https/ws/wss')
def __init__(self, contract, source, destination):
self.contract_address = Web3.toChecksumAddress(contract)
self.source_address = Web3.toChecksumAddress(source)
self.destination_address = Web3.toChecksumAddress(destination)
self.node_url = "wss://mainnet.infura.io/ws/v3/YOUR_TOKEN"
self.w3 = Web3(WebsocketProvider(self.node_url, websocket_kwargs={'timeout': 60}))
self.abi = json.loads(open("./python_base/txchain/erc20.abi", "r").read())
self.contract = self.w3.eth.contract(abi=self.abi, address=self.contract_address)
self.start_block = self.w3.eth.blockNumber - 8640
def __init__(self, network: str, protocol: str = 'http'):
self.conf = conf_for_name(network)
if protocol == 'websocket':
provider = WebsocketProvider(self.conf['websocket'])
else:
provider = HTTPProvider(self.conf['http'])
self.web3 = Web3(provider=provider)
self.chain_id = self.web3.eth.chainId
self.symbol = self.conf['symbol']
def __init__(self, provider_url):
if provider_url.startswith('http'):
self.web3 = Web3(HTTPProvider(provider_url))
elif provider_url.startswith('ws'):
self.web3 = Web3(WebsocketProvider(provider_url))
elif provider_url.endswith('ipc'):
self.web3 = Web3(IPCProvider(provider_url))
else:
raise RuntimeError('Undefined protocol')
def init_infura(self, network):
self.network = network
self.url = 'wss://{subdomain}.infura.io/ws/v3/{proj_id}' \
.format(subdomain=network, proj_id=WEB3_INFURA_PROJECT_ID)
self.interface = Web3(WebsocketProvider(self.url))
if network == 'rinkeby':
self.interface.middleware_onion.inject(geth_poa_middleware,
layer=0)
return
def __init__(self, contract, addresses):
self.contract_address = Web3.toChecksumAddress(contract)
self.addresses = addresses
self.node_url = "wss://mainnet.infura.io/ws/v3/TOKEN_HERE"
self.w3 = Web3(
WebsocketProvider(self.node_url, websocket_kwargs={'timeout': 60}))
self.abi = json.loads(
open("./python_base/crypto/erc20.abi", "r").read())
self.contract = self.w3.eth.contract(abi=self.abi,
address=self.contract_address)
def __init__(self, root_chain_provider=None, child_chain_url="http://localhost:8546/jsonrpc"):
if root_chain_provider is None:
if plasma_config['NETWORK'].startswith("wss://"):
root_chain_provider = WebsocketProvider(plasma_config['NETWORK'])
else:
root_chain_provider = HTTPProvider(plasma_config['NETWORK'])
self.deployer = Deployer(root_chain_provider)
self.w3 = self.deployer.w3
self.root_chain = self.deployer.get_contract_at_address("RootChain", plasma_config['ROOT_CHAIN_CONTRACT_ADDRESS'], concise=False)
self.child_chain = ChildChainService(child_chain_url)
def setUp(self):
self.loop = asyncio.get_event_loop()
augur_host = 'localhost'
augur_port = 9001
ethereum = Web3(
WebsocketProvider('wss://rinkeby.augur.net/ethereum-ws'))
self.client = AugurClient(augur_host,
augur_port,
ethereum_client=ethereum)
self.loop.run_until_complete(self.client.open())
def add_provider(self,
provider: Union[IPCProvider, WebsocketProvider,
HTTPProvider] = None,
provider_uri: str = None,
timeout: int = None) -> None:
if not provider_uri and not provider:
raise self.NoProvider("No URI or provider instances supplied.")
if provider_uri and not provider:
uri_breakdown = urlparse(provider_uri)
# PyEVM
if uri_breakdown.scheme == 'tester':
if uri_breakdown.netloc == 'pyevm':
from nucypher.utilities.sandbox.constants import PYEVM_GAS_LIMIT
genesis_params = PyEVMBackend._generate_genesis_params(
overrides={'gas_limit': PYEVM_GAS_LIMIT})
pyevm_backend = PyEVMBackend(
genesis_parameters=genesis_params)
eth_tester = EthereumTester(backend=pyevm_backend,
auto_mine_transactions=True)
provider = EthereumTesterProvider(
ethereum_tester=eth_tester)
elif uri_breakdown.netloc == 'geth':
# Hardcoded gethdev IPC provider
provider = IPCProvider(ipc_path='/tmp/geth.ipc',
timeout=timeout)
else:
raise ValueError(
"{} is an invalid or unsupported blockchain provider URI"
.format(provider_uri))
# IPC
elif uri_breakdown.scheme == 'ipc':
provider = IPCProvider(ipc_path=uri_breakdown.path,
timeout=timeout)
# Websocket
elif uri_breakdown.scheme == 'ws':
provider = WebsocketProvider(endpoint_uri=provider_uri)
# HTTP
elif uri_breakdown.scheme in ('http', 'https'):
provider = HTTPProvider(endpoint_uri=provider_uri)
else:
raise self.InterfaceError(
"'{}' is not a blockchain provider protocol".format(
uri_breakdown.scheme))
self.__provider = provider
def load_web3(provider = 'HTTP'):
with open('../creds/infura_creds.json') as f:
creds = json.load(f)
if provider == 'HTTP':
w3 = Web3(HTTPProvider(creds[provider]))
elif provider == 'WSS':
w3 = Web3(WebsocketProvider(creds[provider], websocket_kwargs = {websocket_timeout : 50}))
else:
raise ValueError('Provider should be HTTP or WSS, received {} instead'.format(provider))
return w3
def connect(self, uri):
'''Connects to a provider'''
if Path(uri).exists():
self.providers = [IPCProvider(uri)]
elif uri[:3] == "ws:":
self.providers = [WebsocketProvider(uri)]
elif uri[:4] == "http":
self.providers = [HTTPProvider(uri)]
else:
raise ValueError(
"Unknown URI - must be a path to an IPC socket, a websocket "
"beginning with 'ws' or a URL beginning with 'http'")
def __init__(self, web3=None):
if web3:
self.web3 = web3
elif settings.RPC_PROTOCOL == 'https':
self.web3 = Web3(HTTPProvider(settings.RPC_SERVER))
# add geth poa middleware to handle overflowing extraData field
# https://ethereum.stackexchange.com/a/44131
self.web3.middleware_stack.inject(geth_poa_middleware, layer=0)
elif settings.RPC_PROTOCOL == 'wss':
self.web3 = Web3(WebsocketProvider(settings.RPC_SERVER))
self.web3.middleware_stack.inject(geth_poa_middleware, layer=0)
def get_web3_provider():
"""Get Web3 instance. Supports websocket, http, ipc."""
global hostname
protocol = get_setting('rpc', 'protocol')
if hostname is None:
hostname = get_setting('rpc', 'hostname')
port = get_setting('rpc', 'port')
if hostname.find(".r1.") != -1:
hostname = hostname.replace(".r1.", ".r2.")
elif hostname.find(".r2.") != -1:
hostname = hostname.replace(".r2.", ".r1.")
console.info("get_web3_provider, RPC hostname => " + hostname)
timeout = 30
#if timeout is None:
# try:
# timeout = int(get_setting('rpc', 'timeout'))
# except KeyError:
# timeout = 15 # default timeout is 15 seconds
if protocol == 'ws' or protocol == 'wss':
provider = WebsocketProvider(
"%s://%s:%s" % (
protocol,
hostname,
port),
websocket_kwargs={'timeout':timeout}
)
provider.egs_timeout = timeout
return Web3(provider)
elif protocol == 'http' or protocol == 'https':
provider = HTTPProvider(
"%s://%s:%s" % (
protocol,
hostname,
port),
request_kwargs={'timeout':timeout}
)
provider.egs_timeout = timeout
return Web3(provider)
elif protocol == 'ipc':
provider = IPCProvider(
hostname,
timeout=timeout
)
provider.egs_timeout = timeout
return Web3(provider)
else:
raise Exception("Can't set web3 provider type %s" % str(protocol))
def get_web3_connection_provider(network_url):
if network_url.startswith("http"):
provider = CustomHTTPProvider(network_url)
elif network_url.startswith("ws"):
provider = WebsocketProvider(network_url)
elif network_url == "ganache":
provider = CustomHTTPProvider(GANACHE_URL)
elif network_url == "polygon":
provider = CustomHTTPProvider(POLYGON_URL)
else:
assert network_url in SUPPORTED_NETWORK_NAMES, (
f"The given network_url *{network_url}* does not start with either "
f"`http` or `wss`, in this case a network name is expected and must "
f"be one of the supported networks {SUPPORTED_NETWORK_NAMES}.")
network_url = os.getenv("NETWORK_URL")
if network_url.startswith("http"):
provider = CustomHTTPProvider(network_url)
else:
provider = WebsocketProvider(network_url)
return provider
async def main():
global W3
config_filename = f'listener_network_{NETWORK_ID}.ini'
config = ConfigParser()
config.read(config_filename)
if not config.has_section('default'):
config.add_section('default')
if not config.has_option('default', 'last_block_number'):
config.set('default', 'last_block_number', str(W3.eth.blockNumber - 1))
with open(config_filename, 'w') as f:
config.write(f)
last_block_number = int(config.get('default', 'last_block_number'))
tracked_events = await load_event_signatures()
while True:
try:
latest_block = W3.eth.blockNumber
if latest_block > last_block_number:
network_id = W3.eth.chainId
logger.info(f'Block {last_block_number + 1}')
log_items = W3.eth.filter({
'fromBlock': last_block_number + 1,
'toBlock': last_block_number + 1
}).get_all_entries()
for log_item in log_items:
for topic in log_item['topics']:
if topic.hex() in tracked_events:
try:
parsed_event = get_event_data(
tracked_events[topic.hex()], log_item)
if parsed_event['address'] in tracked_events[
topic.hex()]['addresses']:
await process_event(
parsed_event, network_id)
except LogTopicError:
logger.debug('Bad event')
config.set('default', 'last_block_number',
str(last_block_number + 1))
with open(config_filename, 'w') as f:
config.write(f)
last_block_number += 1
except:
logger.error(traceback.format_exc())
W3 = Web3(WebsocketProvider(
settings.NETWORKS[NETWORK_ID].NODE_URL))
await asyncio.sleep(settings.DELAY)
finally:
if latest_block <= last_block_number:
await asyncio.sleep(settings.DELAY)