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 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
