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 ens(self):
if self._ens is default:
return ENS.fromWeb3(self)
else:
return self._ens
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})
def ens(self):
if self._ens is empty:
return ENS.fromWeb3(self)
else:
return self._ens
