def is_connected_with(self, _w3, connection_type, _heart_rate): if not _w3.isConnected(): return False self._w3 = _w3 if self._w3.version.network == '4': self._w3.middleware_stack.inject(geth_poa_middleware, layer=0) self._network = self.w3.version.network self._ns = ENS.fromWeb3(_w3) if self._network == '1' and self._sai_pip is None: self._sai_pip = SaiPip(self) self._heart_rate = _heart_rate self._connection_type = connection_type try: self._update_status() except (UnhandledRequest, StaleBlockchain): return False if self._block_listener is None: logging.info("start block listener") self._block_listener = BlockListener(self, self.config) return True
def set_resolver(signer, github_handle, nonce, gas_multiplier=1.101): if mock_request: return '0x7bce7e4bcd2fea4d26f3d254bb8cf52b9ee8dd7353b19bfbc86803c27d9bbf39' ns = ENS.fromWeb3(w3) resolver_addr = ns.address('resolver.eth') signer = Web3.toChecksumAddress(signer) txn_hash = None gas_price = get_gas_price(gas_multiplier) subdomain = f"{github_handle}.{settings.ENS_TLD}" transaction = { 'from': Web3.toChecksumAddress(settings.ENS_OWNER_ACCOUNT), 'value': 0, 'nonce': nonce, 'gas': Web3.toHex(RESOLVER_GAS_COST), 'gasPrice': Web3.toHex(int(float(gas_price))), } ens_contract = w3.eth.contract(address=ENS_MAINNET_ADDR, abi=ens_abi, ) txn = ens_contract.functions.setResolver(dot_eth_namehash(subdomain), resolver_addr, ).buildTransaction(transaction) signed_txn = w3.eth.account.signTransaction(txn, private_key=settings.ENS_PRIVATE_KEY) try: txn_hash = convert_txn(w3.eth.sendRawTransaction(signed_txn.rawTransaction)) except ValueError as e: logger.warning(f'{e} - set_resolver') return txn_hash
def parse_registry_uri(uri: str) -> RegistryURI: """ Validate and return (authority, chain_id, pkg_name, version) from a valid registry URI. """ from web3.auto.infura import w3 validate_registry_uri(uri) parsed_uri = parse.urlparse(uri) if ":" in parsed_uri.netloc: address_or_ens, chain_id = parsed_uri.netloc.split(":") else: address_or_ens, chain_id = parsed_uri.netloc, "1" ns = ENS.fromWeb3(w3) if is_address(address_or_ens): address = address_or_ens ens = None elif ns.address(address_or_ens): address = ns.address(address_or_ens) ens = address_or_ens else: raise CannotHandleURI( f"Invalid address or ENS domain found in uri: {uri}.") pkg_name, pkg_version, namespaced_asset = _process_pkg_path( parsed_uri.path) return RegistryURI(address, chain_id, pkg_name, pkg_version, namespaced_asset, ens)
def _update(self): w3 = self.w3_getter() # semaphore only allows one thread to wait on update self.update_sem.acquire(blocking=False) with self.update_lock: if self.credstick: self._wei_balance = w3.eth.getBalance( self.credstick.addressStr()) self.erc20_balances = Erc20.balances(self, self.credstick.address) if self.network == '1': try: self.ens = ENS.fromWeb3(_w3) self._ens_domain = self.ens.name( self.credstick.addressStr()) self.eth_price = w3.fromWei(self._sai_pip.eth_price(), 'ether') except BadFunctionCallOutput: self._ens_domain = 'Unknown' else: self._ens_domain = 'Unknown' #self.best_block = str(self.w3.eth.blockNumber) self.best_block = str(w3.eth.blockNumber) self.syncing_hash = w3.eth.syncing if self.syncing_hash not in (None, False): self.blocks_behind = self.syncing_hash[ 'highestBlock'] - self.syncing_hash['currentBlock'] else: self.blocks_behind = None self.update_sem.release()
def _initialize_background(self): self._status = 'STARTING' if self._gateway_config: self._w3 = make_w3(self._gateway_config) else: from web3.auto.infura import w3 self._w3 = w3 self._ens = ENS.fromWeb3(self._w3) if self._name_category in ['ens', 'reverse_ens']: if self._name_category == 'reverse_ens': name = ''.join(reversed(self._name_or_address.split('.'))) else: name = self._name_or_address self._address = self._ens.address(name) elif self._name_category == 'eth': self._address = self._w3.toChecksumAddress(self._name_or_address) else: assert False, 'should not arrive here' # https://web3py.readthedocs.io/en/stable/contracts.html#web3.contract.Contract # https://web3py.readthedocs.io/en/stable/web3.eth.html#web3.eth.Eth.contract # self._contract = self._w3.eth.contract(address=self.CONTRACT_ADDRESS, abi=self.CONTRACT_ABI) # FIXME: get IPFS hash, download file, unzip seeders self._status = 'RUNNING'
def getWeb3(self): try: web3 = web3Connect(self.params) if not web3: raise Exception( f'unsupported provType {self._params.provType}') account = None try: if hasattr(web3, 'personal') and web3.personal.listAccounts: # Geth Node account = web3.personal.listAccounts[0] else: account = web3.eth.accounts[0] # raise Exception('Nothing ..') except Exception: log.debug('No eth account found') self.createAccount(web3) else: web3.eth.defaultAccount = account log.debug(f'Using account {account}', account) self._ns = ENS.fromWeb3(web3) return web3 except Exception as err: log.debug('Cannot get Web3 connector: {}'.format(str(err))) return None
def do_execute(self): registry = config.get_registry() w3_factory = MakeW3(self.chain) w3 = w3_factory.get_w3_obj() ns = ENS.fromWeb3(w3, registry) address = ns.address(self.ens_name) return address == self.contract_address
def ENStoEthAddress(self, ens): """ Convert ENS address to standard Ethereum address. """ if self.w3.isConnected(): ns = ENS.fromWeb3(self.w3) address = ns.address(ens) if address != None: return address else: raise Exception('Address cannot be resolved.') else: raise Exception('Web3 not connected.')
def test_web3_ens(ens): w3 = ens.web3 ns = ENS.fromWeb3(w3, ens.ens.address) w3.ens = ns registry = VyperReferenceRegistry.deploy_new_instance(w3) w3.ens.setup_address('tester.eth', registry.address) actual_addr = ens.address('tester.eth') w3.pm.set_registry('tester.eth') assert w3.pm.registry.address == actual_addr w3.pm.release_package('owned', '1.0.0', 'ipfs://QmbeVyFLSuEUxiXKwSsEjef6icpdTdA4kGG9BcrJXKNKUW') pkg_name, version, manifest_uri = w3.pm.get_release_data('owned', '1.0.0') assert pkg_name == 'owned' assert version == '1.0.0' assert manifest_uri == 'ipfs://QmbeVyFLSuEUxiXKwSsEjef6icpdTdA4kGG9BcrJXKNKUW'
def test_web3_ens(ens): w3 = ens.web3 ns = ENS.fromWeb3(w3, ens.ens.address) w3.ens = ns registry = VyperReferenceRegistry.deploy_new_instance(w3) w3.ens.setup_address('tester.eth', registry.address) actual_addr = ens.address('tester.eth') w3.pm.set_registry('tester.eth') assert w3.pm.registry.address == to_canonical_address(actual_addr) w3.pm.release_package('pkg', 'v1', 'website.com') pkg_name, version, manifest_uri = w3.pm.get_release_data('pkg', 'v1') assert pkg_name == 'pkg' assert version == 'v1' assert manifest_uri == 'website.com'
def test_web3_ens(ens): w3 = ens.web3 ns = ENS.fromWeb3(w3, ens.ens.address) w3.ens = ns registry = SimpleRegistry.deploy_new_instance(w3) w3.ens.setup_address('tester.eth', registry.address) actual_addr = ens.address('tester.eth') w3.pm.set_registry('tester.eth') assert w3.pm.registry.address == actual_addr w3.pm.release_package('owned', '1.0.0', 'ipfs://QmcxvhkJJVpbxEAa6cgW3B6XwPJb79w9GpNUv2P2THUzZR') pkg_name, version, manifest_uri = w3.pm.get_release_data('owned', '1.0.0') assert pkg_name == 'owned' assert version == '1.0.0' assert manifest_uri == 'ipfs://QmcxvhkJJVpbxEAa6cgW3B6XwPJb79w9GpNUv2P2THUzZR'
def getWeb3(self): try: if self._params.provType == 'http': web3 = Web3(Web3.HTTPProvider(self.params.rpcUrl)) elif self._params.provType == 'websocket': web3 = Web3(WebsocketProvider(self.params.rpcUrl)) return web3 web3.eth.defaultAccount = web3.eth.accounts[0] self._ns = ENS.fromWeb3(web3) return web3 except Exception as err: log.debug('Cannot get Web3 connector: {}'.format(str(err))) return None
def _resolve_address(address: str) -> str: if not isinstance(address, str) or "." not in address: return to_address(address) address = address.lower() if address not in _ens_cache: try: ns = ENS.fromWeb3(web3._mainnet) except MainnetUndefined as e: raise MainnetUndefined( f"Cannot resolve ENS address - {e}") from None resolved_address = ns.address(address) _ens_cache[address] = resolved_address if _ens_cache[address] is None: raise UnsetENSName(f"ENS address '{address}' is not set") return _ens_cache[address]
def __init__(self, address: str, node_url: str): self.address = address self.node_url = node_url self.ethereum_client = EthereumClient(self.node_url) self.ens = ENS.fromWeb3(self.ethereum_client.w3) self.network: EthereumNetwork = self.ethereum_client.get_network() self.network_name: str = self.network.name self.network_number: int = self.network.value self.etherscan = Etherscan.from_network_number(self.network_number) self.safe_tx_service_url = TransactionService.from_network_number(self.network_number) self.safe_relay_service_url = RelayService.from_network_number(self.network_number) self.safe = Safe(address, self.ethereum_client) self.safe_contract = self.safe.get_contract() self.accounts: Set[Account] = set() self.default_sender: Optional[Account] = None self.executed_transactions: List[str] = [] self._safe_cli_info: Optional[SafeCliInfo] = None # Cache for SafeCliInfo
def _resolve_address(domain: str) -> str: # convert ENS domain to address if not isinstance(domain, str) or "." not in domain: return to_address(domain) domain = domain.lower() if domain not in _ens_cache or time.time() - _ens_cache[domain][1] > 86400: try: ns = ENS.fromWeb3(web3._mainnet) except MainnetUndefined as e: raise MainnetUndefined(f"Cannot resolve ENS address - {e}") from None address = ns.address(domain) _ens_cache[domain] = [address, int(time.time())] with _get_path().open("w") as fp: json.dump(_ens_cache, fp) if _ens_cache[domain][0] is None: raise UnsetENSName(f"ENS domain '{domain}' is not set") return _ens_cache[domain][0]
def __init__(self): # self.web3 = Web3(Web3.HTTPProvider(self.ganache_url)) self.web3 = Web3(Web3.HTTPProvider(self.infura_url)) self.ns = ENS.fromWeb3(self.web3) # self.web3 = Web3(Web3.WebsocketProvider(self.infura_wss)) if(not self.web3.isConnected()): print("-------------------Blockchain Access--------------------------") print('Connection to {}: Failed\nExiting...'.format(self.web3.provider)) print("--------------------------------------------------------------") exit() else: print("-------------------Blockchain Access--------------------------") print('Connection to {}: established'.format(self.web3.provider)) print("--------------------------------------------------------------") with open('../truffle stuff/build/contracts/PagareTracker.json') as json_file: abi = json.load(json_file)['abi'] # Contrato principal self.contractAddress = self.web3.toChecksumAddress( '0x9D7F19128E83DcBa77271FEE9d72BD70C9fa2048') self.contract = self.web3.eth.contract( address=self.contractAddress, abi=abi) with open('resolver.json') as json_file: abi_resolver = json.load(json_file) with open('registry.json') as json_file: abi_registry = json.load(json_file) # Contrato ENS resolver self.resolverAddress = self.web3.toChecksumAddress( '0x42D63ae25990889E35F215bC95884039Ba354115') self.resolverContract = self.web3.eth.contract( address=self.resolverAddress, abi=abi_resolver) # Contrato ENS Register self.registerAddress = self.web3.toChecksumAddress( '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e') self.registryContract = self.web3.eth.contract( address=self.registerAddress, abi=abi_registry)
def set_resolver(signer, github_handle, nonce, gas_multiplier=1): if mock_request: return '0x7bce7e4bcd2fea4d26f3d254bb8cf52b9ee8dd7353b19bfbc86803c27d9bbf39' ns = ENS.fromWeb3(w3) resolver_addr = ns.address('resolver.eth') signer = Web3.toChecksumAddress(signer) txn_hash = None gasPrice = recommend_min_gas_price_to_confirm_in_time( 1) * 10**9 if not settings.DEBUG else 15 * 10**9 * gas_multiplier subdomain = f"{github_handle}.{settings.ENS_TLD}" transaction = { 'from': Web3.toChecksumAddress(settings.ENS_OWNER_ACCOUNT), 'value': 0, 'nonce': nonce, 'gas': Web3.toHex(100000), 'gasPrice': Web3.toHex(int(float(gasPrice))), } ens_contract = w3.eth.contract( address=ENS_MAINNET_ADDR, abi=ens_abi, ) txn = ens_contract.functions.setResolver( dot_eth_namehash(subdomain), resolver_addr, ).buildTransaction(transaction) signed_txn = w3.eth.account.signTransaction( txn, private_key=settings.ENS_PRIVATE_KEY) txn_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction) # hack to convert # "b'7bce7e4bcd2fea4d26f3d254bb8cf52b9ee8dd7353b19bfbc86803c27d9bbf39'" # to "0x7bce7e4bcd2fea4d26f3d254bb8cf52b9ee8dd7353b19bfbc86803c27d9bbf39" txn_hash = str(binascii.b2a_hex(txn_hash)).replace("b'", "0x").replace("'", "") return txn_hash
def parse_registry_uri(uri: str) -> RegistryURI: """ Validate and return (authority, pkg name, version) from a valid registry URI """ from web3.auto.infura import w3 validate_registry_uri(uri) parsed_uri = parse.urlparse(uri) address_or_ens, chain_id = parsed_uri.netloc.split(":") ns = ENS.fromWeb3(w3) if is_address(address_or_ens): address = address_or_ens ens = None elif ns.address(address_or_ens): address = ns.address(address_or_ens) ens = address_or_ens else: raise CannotHandleURI( f"Invalid address or ENS domain found in uri: {uri}.") parsed_name = parsed_uri.path.strip("/") parsed_version = parsed_uri.query.lstrip("version=").strip("/") pkg_name = parsed_name if parsed_name else None pkg_version = parsed_version if parsed_version else None return RegistryURI(address, chain_id, pkg_name, pkg_version, ens)
def __init__(self, address: str, node_url: str): self.address = address self.node_url = node_url self.ethereum_client = EthereumClient(self.node_url) self.ens = ENS.fromWeb3(self.ethereum_client.w3) self.network: EthereumNetwork = self.ethereum_client.get_network() self.etherscan = EtherscanApi.from_ethereum_client( self.ethereum_client) self.safe_relay_service = RelayServiceApi.from_ethereum_client( self.ethereum_client) self.safe_tx_service = TransactionServiceApi.from_ethereum_client( self.ethereum_client) self.safe = Safe(address, self.ethereum_client) self.safe_contract = self.safe.get_contract() self.safe_contract_1_1_0 = get_safe_V1_1_1_contract( self.ethereum_client.w3, address=self.address) self.accounts: Set[LocalAccount] = set() self.default_sender: Optional[LocalAccount] = None self.executed_transactions: List[str] = [] self._safe_cli_info: Optional[ SafeCliInfo] = None # Cache for SafeCliInfo self.require_all_signatures = ( True # Require all signatures to be present to send a tx )
def ens_setup(): w3 = Web3(EthereumTesterProvider(EthereumTester())) # ** Set up ENS contracts ** # remove account that creates ENS, so test transactions don't have write access accounts = w3.eth.accounts ens_key = accounts.pop() # create ENS contract eth_labelhash = w3.sha3(text='eth') eth_namehash = bytes32(0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae) resolver_namehash = bytes32(0xfdd5d5de6dd63db72bbc2d487944ba13bf775b50a80805fe6fcaba9b0fba88f5) reverse_tld_namehash = bytes32(0xa097f6721ce401e757d1223a763fef49b8b5f90bb18567ddb86fd205dff71d34) # noqa: E501 reverser_namehash = bytes32(0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2) ens_contract = deploy(w3, ENSFactory, ens_key) # create public resolver public_resolver = deploy(w3, PublicResolverFactory, ens_key, args=[ens_contract.address]) # set 'resolver.eth' to resolve to public resolver ens_contract.transact({'from': ens_key}).setSubnodeOwner( b'\0' * 32, eth_labelhash, ens_key ) ens_contract.transact({'from': ens_key}).setSubnodeOwner( eth_namehash, w3.sha3(text='resolver'), ens_key ) ens_contract.transact({'from': ens_key}).setResolver(resolver_namehash, public_resolver.address) public_resolver.transact({'from': ens_key}).setAddr(resolver_namehash, public_resolver.address) # create .eth auction registrar eth_registrar = deploy( w3, ETHRegistrarFactory, ens_key, args=[ens_contract.address, eth_namehash, 1], ) # set '.eth' to resolve to the registrar ens_contract.transact({'from': ens_key}).setResolver(eth_namehash, public_resolver.address) public_resolver.transact({'from': ens_key}).setAddr( eth_namehash, eth_registrar.address ) # create reverse resolver reverse_resolver = deploy(w3, DefaultReverseResolver, ens_key, args=[ens_contract.address]) # create reverse registrar reverse_registrar = deploy( w3, ReverseRegistrar, ens_key, args=[ens_contract.address, reverse_resolver.address] ) # set 'addr.reverse' to resolve to reverse registrar ens_contract.transact({'from': ens_key}).setSubnodeOwner( b'\0' * 32, w3.sha3(text='reverse'), ens_key ) ens_contract.transact({'from': ens_key}).setSubnodeOwner( reverse_tld_namehash, w3.sha3(text='addr'), ens_key ) ens_contract.transact({'from': ens_key}).setResolver(reverser_namehash, public_resolver.address) public_resolver.transact({'from': ens_key}).setAddr( reverser_namehash, reverse_registrar.address ) # set owner of tester.eth to an account controlled by tests ens_contract.transact({'from': ens_key}).setSubnodeOwner( eth_namehash, w3.sha3(text='tester'), w3.eth.accounts[2] # note that this does not have to be the default, only in the list ) # make the registrar the owner of the 'eth' name ens_contract.transact({'from': ens_key}).setSubnodeOwner( b'\0' * 32, eth_labelhash, eth_registrar.address ) # make the reverse registrar the owner of the 'addr.reverse' name ens_contract.transact({'from': ens_key}).setSubnodeOwner( reverse_tld_namehash, w3.sha3(text='addr'), reverse_registrar.address ) return ENS.fromWeb3(w3, ens_contract.address)
"0x112234455C3a32FD11230C42E7Bccd4A84e02010", "abi": '[{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"resolver","type":"address"}],"name":"setResolver","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"label","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setSubnodeOwner","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"ttl","type":"uint64"}],"name":"setTTL","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":true,"name":"label","type":"bytes32"},{"indexed":false,"name":"owner","type":"address"}],"name":"NewOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"owner","type":"address"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"resolver","type":"address"}],"name":"NewResolver","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"ttl","type":"uint64"}],"name":"NewTTL","type":"event"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"resolver","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"ttl","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"}]' }, "PublicResolver": { "mainnet": "0x314159265dD8dbb310642f98f50C066173C1259b", "ropsten": "0x5FfC014343cd971B7eb70732021E26C35B744cc4", "abi": '[{"constant":true,"inputs":[{"name":"interfaceID","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"key","type":"string"},{"name":"value","type":"string"}],"name":"setText","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"},{"name":"contentTypes","type":"uint256"}],"name":"ABI","outputs":[{"name":"contentType","type":"uint256"},{"name":"data","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"x","type":"bytes32"},{"name":"y","type":"bytes32"}],"name":"setPubkey","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"hash","type":"bytes"}],"name":"setContenthash","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"hash","type":"bytes32"}],"name":"setContent","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"addr","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"content","outputs":[{"name":"ret","type":"bytes32"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"},{"name":"key","type":"string"}],"name":"text","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"contentType","type":"uint256"},{"name":"data","type":"bytes"}],"name":"setABI","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"name","type":"string"}],"name":"setName","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"contenthash","outputs":[{"name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"pubkey","outputs":[{"name":"x","type":"bytes32"},{"name":"y","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"addr","type":"address"}],"name":"setAddr","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"ensAddr","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"a","type":"address"}],"name":"AddrChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"name","type":"string"}],"name":"NameChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":true,"name":"contentType","type":"uint256"}],"name":"ABIChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"x","type":"bytes32"},{"indexed":false,"name":"y","type":"bytes32"}],"name":"PubkeyChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"indexedKey","type":"string"},{"indexed":false,"name":"key","type":"string"}],"name":"TextChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes"}],"name":"ContenthashChanged","type":"event"}]' } } w3 = {net: Web3(web3_data['provider'][net]) for net in web3_data['provider']} ns = {net: ENS.fromWeb3(w3[net]) for net in w3} web3_data['ENSRegistry']['contract'] = { net: w3[net].eth.contract(web3_data['ENSRegistry'][net], abi=web3_data['ENSRegistry']['abi']) for net in w3 } web3_data['PublicResolver']['contract'] = { net: w3[net].eth.contract(web3_data['PublicResolver'][net], abi=web3_data['PublicResolver']['abi']) for net in w3 } @app.route('/search', methods=['GET']) def search():
def ens(self) -> ENS: if self._ens is cast(ENS, empty): return ENS.fromWeb3(self) else: return self._ens
def ens(self): if self._ens is empty: return ENS.fromWeb3(self) else: return self._ens
def __init__(self) -> None: self.ns = _ens.fromWeb3(w3) pass
def ens(self): if self._ens is default: return ENS.fromWeb3(self) else: return self._ens
def ens_setup(deployer): # todo: move to module level once ethpm alpha stable ENS_MANIFEST = ASSETS_DIR / 'ens' / '1.0.1.json' ens_deployer = deployer(ENS_MANIFEST) w3 = ens_deployer.package.w3 # ** Set up ENS contracts ** # remove account that creates ENS, so test transactions don't have write access accounts = w3.eth.accounts ens_key = accounts.pop() # create ENS contract # values borrowed from: # https://github.com/ethereum/web3.py/blob/master/tests/ens/conftest.py#L109 eth_labelhash = w3.keccak(text='eth') eth_namehash = bytes32( 0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae) resolver_namehash = bytes32( 0xfdd5d5de6dd63db72bbc2d487944ba13bf775b50a80805fe6fcaba9b0fba88f5) ens_package = ens_deployer.deploy("ENSRegistry", transaction={"from": ens_key}) ens_contract = ens_package.deployments.get_instance("ENSRegistry") # create public resolver public_resolver_package = ens_deployer.deploy( "PublicResolver", ens_contract.address, transaction={"from": ens_key}) public_resolver = public_resolver_package.deployments.get_instance( "PublicResolver") # set 'resolver.eth' to resolve to public resolver ens_contract.functions.setSubnodeOwner(b'\0' * 32, eth_labelhash, ens_key).transact({'from': ens_key}) ens_contract.functions.setSubnodeOwner(eth_namehash, w3.keccak(text='resolver'), ens_key).transact({'from': ens_key}) ens_contract.functions.setResolver( resolver_namehash, public_resolver.address).transact({'from': ens_key}) public_resolver.functions.setAddr( resolver_namehash, public_resolver.address).transact({'from': ens_key}) # create .eth auction registrar eth_registrar_package = ens_deployer.deploy("FIFSRegistrar", ens_contract.address, eth_namehash, transaction={"from": ens_key}) eth_registrar = eth_registrar_package.deployments.get_instance( "FIFSRegistrar") # set '.eth' to resolve to the registrar ens_contract.functions.setResolver( eth_namehash, public_resolver.address).transact({'from': ens_key}) public_resolver.functions.setAddr( eth_namehash, eth_registrar.address).transact({'from': ens_key}) # set owner of tester.eth to an account controlled by tests ens_contract.functions.setSubnodeOwner( eth_namehash, w3.keccak(text='tester'), w3.eth.accounts[ 2] # note that this does not have to be the default, only in the list ).transact({'from': ens_key}) # make the registrar the owner of the 'eth' name ens_contract.functions.setSubnodeOwner(b'\0' * 32, eth_labelhash, eth_registrar.address).transact( {'from': ens_key}) return ENS.fromWeb3(w3, ens_contract.address)
import logging from datetime import datetime, timedelta from django.core.management.base import BaseCommand from user.models import User from web3 import Web3, HTTPProvider from ens import ENS from django.conf import settings web3 = Web3(HTTPProvider(settings.NETWORKS['mainNet'])) ns = ENS.fromWeb3(web3) logger = logging.getLogger('django') class Command(BaseCommand): help = 'Script to find ens domains for users' def handle(self, *args, **options): try: last_date = datetime.utcnow() - timedelta(days=1) users = User.objects.all().filter(last_logged_in__gte=last_date) for user in users: public_address = Web3.toChecksumAddress(user.public_address) domain = ns.name(public_address) if domain is not None: parts = domain.split('.') if len(parts) == 2 and parts[1] == 'eth': user.ens_domain = domain user.save() except Exception as e:
def test_fromWeb3_inherits_web3_middlewares(w3): test_middleware = pythonic_middleware w3.middleware_onion.add(test_middleware, 'test_middleware') ns = ENS.fromWeb3(w3) assert ns.w3.middleware_onion.get('test_middleware') == test_middleware
def ens_setup(): w3 = Web3(EthereumTesterProvider(EthereumTester())) # ** Set up ENS contracts ** # remove account that creates ENS, so test transactions don't have write access accounts = w3.eth.accounts ens_key = accounts.pop() # create ENS contract eth_labelhash = w3.keccak(text='eth') eth_namehash = bytes32( 0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae) resolver_namehash = bytes32( 0xfdd5d5de6dd63db72bbc2d487944ba13bf775b50a80805fe6fcaba9b0fba88f5) reverse_tld_namehash = bytes32( 0xa097f6721ce401e757d1223a763fef49b8b5f90bb18567ddb86fd205dff71d34 ) # noqa: E501 reverser_namehash = bytes32( 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2) ens_contract = deploy(w3, ENSFactory, ens_key) # create public resolver public_resolver = deploy(w3, PublicResolverFactory, ens_key, args=[ens_contract.address]) # set 'resolver.eth' to resolve to public resolver ens_contract.functions.setSubnodeOwner(b'\0' * 32, eth_labelhash, ens_key).transact({'from': ens_key}) ens_contract.functions.setSubnodeOwner(eth_namehash, w3.keccak(text='resolver'), ens_key).transact({'from': ens_key}) ens_contract.functions.setResolver( resolver_namehash, public_resolver.address).transact({'from': ens_key}) public_resolver.functions.setAddr( resolver_namehash, public_resolver.address).transact({'from': ens_key}) # create .eth registrar eth_registrar = deploy( w3, ENSRegistryFactory, ens_key, args=[ens_contract.address, eth_namehash], ) # set '.eth' to resolve to the registrar ens_contract.functions.setResolver( eth_namehash, public_resolver.address).transact({'from': ens_key}) public_resolver.functions.setAddr( eth_namehash, eth_registrar.address).transact({'from': ens_key}) # create reverse resolver reverse_resolver = deploy(w3, DefaultReverseResolver, ens_key, args=[ens_contract.address]) # create reverse registrar reverse_registrar = deploy( w3, ReverseRegistrar, ens_key, args=[ens_contract.address, reverse_resolver.address]) # set 'addr.reverse' to resolve to reverse registrar ens_contract.functions.setSubnodeOwner(b'\0' * 32, w3.keccak(text='reverse'), ens_key).transact({'from': ens_key}) ens_contract.functions.setSubnodeOwner(reverse_tld_namehash, w3.keccak(text='addr'), ens_key).transact({'from': ens_key}) ens_contract.functions.setResolver( reverser_namehash, public_resolver.address).transact({'from': ens_key}) public_resolver.functions.setAddr(reverser_namehash, reverse_registrar.address).transact( {'from': ens_key}) # set owner of tester.eth to an account controlled by tests second_account = w3.eth.accounts[2] ens_contract.functions.setSubnodeOwner( eth_namehash, w3.keccak(text='tester'), second_account # note that this does not have to be the default, only in the list ).transact({'from': ens_key}) # --- setup simple resolver example --- # # create simple resolver simple_resolver = deploy(w3, SimpleResolver, ens_key, args=[ens_contract.address]) # set owner of simple-resolver.eth to an account controlled by tests ens_contract.functions.setSubnodeOwner(eth_namehash, w3.keccak(text='simple-resolver'), second_account).transact( {'from': ens_key}) # ns.namehash('simple-resolver.eth') simple_resolver_namehash = bytes32( 0x65db4c1c4f4ab9e6917fa7896ce546b1fe03e9341e98187e3917afb60aa9835a) ens_contract.functions.setResolver(simple_resolver_namehash, simple_resolver.address).transact( {'from': second_account}) # --- setup extended resolver example --- # # create extended resolver extended_resolver = deploy(w3, ExtendedResolver, ens_key, args=[ens_contract.address]) # set owner of extended-resolver.eth to an account controlled by tests ens_contract.functions.setSubnodeOwner(eth_namehash, w3.keccak(text='extended-resolver'), second_account).transact( {'from': ens_key}) # ns.namehash('extended-resolver.eth') extended_resolver_namehash = bytes32( 0xf0a378cc2afe91730d0105e67d6bb037cc5b8b6bfec5b5962d9b637ff6497e55) ens_contract.functions.setResolver(extended_resolver_namehash, extended_resolver.address).transact( {'from': second_account}) # --- setup offchain resolver example --- # # create offchain resolver offchain_resolver = deploy( w3, OffchainResolver, ens_key, # use a made up url and mock the call to this endpoint in tests args=[ [ "https://web3.py/gateway/{sender}/{data}.json", # for GET request testing "https://web3.py/gateway/{sender}.json", # for POST request testing ], [ to_checksum_address( '0x4c40caf7f24a545095299972c381862469b080fb') ] ]) # set owner of offchainexample.eth to an account controlled by tests ens_contract.functions.setSubnodeOwner(eth_namehash, w3.keccak(text='offchainexample'), second_account).transact( {'from': ens_key}) # ns.namehash('offchainexample.eth') offchain_example_namehash = bytes32( 0x42041b0018edd29d7c17154b0c671acc0502ea0b3693cafbeadf58e6beaaa16c) ens_contract.functions.setResolver(offchain_example_namehash, offchain_resolver.address).transact( {'from': second_account}) # --- finish setup --- # # make the registrar the owner of the 'eth' name ens_contract.functions.setSubnodeOwner(b'\0' * 32, eth_labelhash, eth_registrar.address).transact( {'from': ens_key}) # make the reverse registrar the owner of the 'addr.reverse' name ens_contract.functions.setSubnodeOwner(reverse_tld_namehash, w3.keccak(text='addr'), reverse_registrar.address).transact( {'from': ens_key}) return ENS.fromWeb3(w3, ens_contract.address)
import base64 from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import padding from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives.serialization import load_pem_public_key from flask import Flask from flask import request, jsonify from flask_cors import CORS, cross_origin app = Flask(__name__) cors = CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' w3 = Web3(Web3.WebsocketProvider("wss://mainnet.infura.io/ws")) ns = ENS.fromWeb3(w3) @app.route("/resolve", methods=["POST"]) @cross_origin() def resolve_ens(): data = request.json ens_name = data["name"] pubkey = data["pubkey"] addr = ns.address(ens_name) public_key_pem_loaded = load_pem_public_key(pubkey.encode(), backend=default_backend()) encrypted_addr = encrypt(public_key_pem_loaded, addr) return jsonify({"encryptedAddress": encrypted_addr, "address": addr, "name": ens_name})