def __init__(self): ''' Robonomics liability tracking node initialisation. ''' rospy.init_node('robonomics_liability_listener') http_provider = HTTPProvider(rospy.get_param('~web3_http_provider')) self.ens = ENS(http_provider, addr=rospy.get_param('~ens_contract', None)) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.poll_interval = rospy.get_param('~poll_interval', 5) self.liability = rospy.Publisher('incoming', Liability, queue_size=10) factory_abi = json.loads(rospy.get_param('~factory_contract_abi')) factory_address = self.ens.address(rospy.get_param('~factory_contract')) self.factory = self.web3.eth.contract(factory_address, abi=factory_abi) self.liability_abi = json.loads(rospy.get_param('~liability_contract_abi')) self.result_handler()
def __init__(self, *args): rospy.init_node(NAME) super(TestExecutor, self).__init__(*args) ipfs_provider = urlparse( rospy.get_param('~ipfs_http_provider')).netloc.split(':') self.ipfs = ipfsapi.connect(ipfs_provider[0], int(ipfs_provider[1])) self.test_token = rospy.get_param('~test_token') self.test_bid_publisher = rospy.Publisher( '/liability/infochan/eth/signing/offer', Offer, queue_size=10) self.test_ask_publisher = rospy.Publisher( '/liability/infochan/eth/signing/demand', Demand, queue_size=10) web3_http_provider = rospy.get_param('~web3_http_provider') http_provider = HTTPProvider(web3_http_provider) ens_contract = rospy.get_param('~ens_contract', None) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.lighthouse_address = self.ens.address( rospy.get_param('~lighthouse_contract')) self.test_start_time = time.time() self.success = False self.ready_liability = None
class ETHUtils: def __init__(self, account, web3_http_provider, ens_contract, erc20_token=None, abi=None): http_provider = HTTPProvider(web3_http_provider) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) if erc20_token is not None and abi is not None: token_address = self.ens.address(erc20_token) self.erc20 = self.web3.eth.contract(token_address, abi=abi) self.erc20_balance_delimiter = (10 ** self.erc20.functions.decimals().call()) self.__account = account @property def erc20Contract(self): return self.erc20 @property def getCurrentBlockNumber(self): return self.web3.eth.blockNumber def getAddressByName(self, name): return self.ens.address(name) def getAccountTransactionCount(self): return self.web3.eth.getTransactionCount(self.__account.address) def signTransaction(self, tx): return self.__account.signTransaction(tx) def sendRawTransaction(self, raw_tx): return self.web3.eth.sendRawTransaction(raw_tx) def signAndSendTransaction(self, tx): signed_tx = self.signTransaction(tx=tx) return self.sendRawTransaction(raw_tx=signed_tx.rawTransaction) def getTransaction(self, tx_hash): return self.web3.eth.getTransaction(tx_hash) def getBalance(self, account): return self.web3.fromWei(self.web3.eth.getBalance(account), 'ether') def getTokenBalance(self, account): return self.erc20.functions.balanceOf(account).call() / self.erc20_balance_delimiter def getAllowance(self, account, address): return self.erc20.functions.allowance(account, address).call()
def __init__(self, *args): rospy.init_node(NAME) super(TestExecutor, self).__init__(*args) self.ipfs_client = build_client(rospy.get_param('~ipfs_http_provider')) self.test_token = rospy.get_param('~test_token') self.test_bid_publisher = rospy.Publisher('/liability/test_executor/o/eth/signing/offer', Offer, queue_size=10) self.test_ask_publisher = rospy.Publisher('/liability/test_executor/d/eth/signing/demand', Demand, queue_size=10) web3_http_provider = rospy.get_param('~web3_http_provider') http_provider = HTTPProvider(web3_http_provider) ens_contract = rospy.get_param('~ens_contract', None) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.lighthouse_address = rospy.get_param('~lighthouse_contract') self.test_start_time = time.time() self.success = False self.ready_liability = None self.test_objective = self.create_test_objective() rospy.logwarn("TEST EXECUTOR: CURRENT OBJECTIVE is %s", self.test_objective)
def _assign_ens(self): ''' Updates ENS entries ''' # prepare domain ens_domain = self._ens_name node = ENS.namehash(ens_domain) # connect to registry and resolver ens_registry = ContractConnection("ens_registry", self.app_config) ens_resolver = ContractConnection("ens_resolver", self.app_config) # set resolver curr_resolver = ens_registry.functions.call("resolver", node) if curr_resolver == "0x0000000000000000000000000000000000000000": resolver_address = ContractConnection.get_ens_address(self.app_config.chain, "ens_resolver") ens_registry.functions.transact("setResolver", node, resolver_address) else: logging.info("Resolver already set for %s", ens_domain) # set ABI ens_resolver.functions.transact("setABI", node, 1, json.dumps(self.abi).encode()) # set address self.contr_address = self._w3.toChecksumAddress(self.contr_address) ens_resolver.functions.transact("setAddr", node, self.contr_address) ens_resolver.functions.transact("setName", node, ens_domain) # get data for output addr = ens_resolver.functions.call("addr", node) name = ens_resolver.functions.call("name", node) logging.info("SUCCESS – Set contract with address %s to name %s", addr, name)
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 __init__(self, account, web3_http_provider, ens_contract, erc20_token=None, abi=None): http_provider = HTTPProvider(web3_http_provider) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) if erc20_token is not None and abi is not None: token_address = self.ens.address(erc20_token) self.erc20 = self.web3.eth.contract(token_address, abi=abi) self.erc20_balance_delimiter = (10 ** self.erc20.functions.decimals().call()) self.__account = account
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 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 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 _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'
class Node: def __init__(self): rospy.init_node('erc20_node', anonymous=True) http_provider = HTTPProvider(rospy.get_param('~web3_http_provider')) self.ens = ENS(http_provider, addr=rospy.get_param('~ens_contract', None)) self.web3 = Web3(http_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) token_address = self.ens.address(rospy.get_param('~token_contract')) self.erc20 = self.web3.eth.contract(token_address, abi=ABI) self.transfer = rospy.Publisher('event/transfer', TransferEvent, queue_size=10) self.approval = rospy.Publisher('event/approval', ApprovalEvent, queue_size=10) rospy.Service( 'transfer', Transfer, lambda m: TransferResponse( self.erc20.functions.transfer(m.to.address, int(m.value.uint256 )).transact())) rospy.Service( 'transfer_from', TransferFrom, lambda m: TransferFromResponse( self.erc20.functions .transferFrom(m.owner.address, m.to.address, int(m.value.uint256)).transact())) rospy.Service( 'approve', Approve, lambda m: ApproveResponse( self.erc20.functions.approve(m.spender.address, int(m.value.uint256)).transact())) rospy.Service( 'accounts', Accounts, lambda m: AccountsResponse( list(map(strToAddress, self.web3.eth.accounts)))) def spin(self): transfer_filter = self.erc20.eventFilter('Transfer') approval_filter = self.erc20.eventFilter('Approval') def filter_thread(): for e in transfer_filter.get_new_entries(): self.transfer.publish(transferEvent(e['args'])) for e in approval_filter.get_new_entries(): self.approval.publish(approvalEvent(e['args'])) Timer(1, filter_thread).start() filter_thread() rospy.spin()
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 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 __init__(self, abi, web3_http_provider="http://localhost:8545", ens_contract=None): http_provider = HTTPProvider(web3_http_provider) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) self.abi = abi
def is_ens_name(value): if not isinstance(value, str): return False elif is_hex_address(value): return False elif is_0x_prefixed(value) and is_hex(value): return False else: return ENS.is_valid_name(value)
def __init__(self): ''' Robonomics liability tracking node initialisation. ''' rospy.init_node('robonomics_liability_listener') web3_http_provider = rospy.get_param('~web3_http_provider') http_provider = HTTPProvider(web3_http_provider) web3_ws_provider = rospy.get_param('~web3_ws_provider') ws_provider = WebsocketProvider(web3_ws_provider) ens_contract = rospy.get_param('~ens_contract', None) self.ens = ENS(http_provider, addr=ens_contract) self.web3 = Web3(http_provider, ens=self.ens) self.web3ws = Web3(ws_provider, ens=self.ens) from web3.middleware import geth_poa_middleware # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.ens.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.poll_interval = rospy.get_param('~poll_interval', 5) self.liability = rospy.Publisher('incoming', Liability, queue_size=10) self.create_liability_filter() self.liability_abi = json.loads( rospy.get_param('~liability_contract_abi')) self.liability_finalization_checker = finalization_checker.FinalizationChecker( self.liability_abi, web3_http_provider=web3_http_provider, ens_contract=ens_contract) self.finalized = rospy.Publisher('finalized', String, queue_size=10) self.liabilities_queue = PersistentQueue( 'robonomics_liability_listener.queue') self.result_handler()
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 _security_check(self): ''' Makes sure that an existing contract does not get overwritten unintensionally ''' # connect to public resolver ens_resolver = ContractConnection("ens_resolver", self.app_config) node = ENS.namehash(self._ens_name) temp = ens_resolver.functions.call("addr", node) # check if ens address is already linked to a contract and potential overwriting intended if temp != "0x0000000000000000000000000000000000000000" and self.app_config.overwrite_ens_link is not True: logging.error("A smart Contract already deployed on this domain and overwrite_ens_link is not True.") exit("Stopping process.")
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 = 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 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 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 _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, 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 __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 __init__(self): ''' Market reporter initialisation. ''' rospy.init_node('robonomics_lighthouse') http_provider = HTTPProvider(rospy.get_param('~web3_http_provider')) ens = ENS(http_provider, addr=rospy.get_param('~ens_contract', None)) self.web3 = Web3(http_provider, ens=ens) # inject the poa compatibility middleware to the innermost layer self.web3.middleware_stack.inject(middleware.geth_poa_middleware, layer=0) ens.web3.middleware_stack.inject(middleware.geth_poa_middleware, layer=0) self.web3.middleware_stack.add(middleware.time_based_cache_middleware) self.web3.middleware_stack.add( middleware.latest_block_based_cache_middleware) self.web3.middleware_stack.add(middleware.simple_cache_middleware) self.liability_abi = json.loads(rospy.get_param('~liability_abi')) lighthouse_abi = json.loads(rospy.get_param('~lighthouse_abi')) lighthouse_contract = rospy.get_param('~lighthouse_contract') self.lighthouse = self.web3.eth.contract(lighthouse_contract, abi=lighthouse_abi) __keyfile = rospy.get_param('~keyfile') __keyfile_password_file = rospy.get_param('~keyfile_password_file') __keyfile_helper = eth_keyfile_helper.KeyfileHelper( __keyfile, keyfile_password_file=__keyfile_password_file) __account = __keyfile_helper.get_local_account_from_keyfile() self.account_address = __account.address rospy.Subscriber('infochan/incoming/result', Result, self.settle_result) rospy.Subscriber('deal', Deal, self.settle_deal) self.setupGasStrategy() self.createQuotaManager()
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 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)
def test_reverse_domain(address, expected_reverse, address_conversion_func): address = address_conversion_func(address) assert ENS.reverse_domain(address) == expected_reverse
def test_reverse_domain(address, expected_reverse): assert ENS.reverse_domain(address) == expected_reverse
def ens(self): if self._ens is default: return ENS.fromWeb3(self) else: return self._ens
def ens(self): if self._ens is empty: return ENS.fromWeb3(self) else: return self._ens