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)