def init_web3(providers=default):
from newchain_web3 import Web3
if providers is default:
w3 = Web3(ens=None)
else:
w3 = Web3(providers, ens=None)
return customize_web3(w3)
def setup_w3():
genesis_overrides = {"gas_limit": 5500000}
custom_genesis_params = PyEVMBackend._generate_genesis_params(
overrides=genesis_overrides)
pyevm_backend = PyEVMBackend(genesis_parameters=custom_genesis_params)
t = EthereumTester(backend=pyevm_backend)
w3 = Web3(Web3.EthereumTesterProvider(ethereum_tester=t))
w3.eth.defaultAccount = w3.eth.accounts[0]
w3.eth.defaultContractFactory = LinkableContract
w3.enable_unstable_package_management_api()
return w3
def test_solidityKeccak_ens(self, web3, types, values, expected):
with ens_addresses(web3, {
'one.eth': "0x49EdDD3769c0712032808D86597B84ac5c2F5614",
'two.eth': "0xA6b759bBbf4B59D24acf7E06e79f3a5D104fdCE5",
}):
# when called as class method, any name lookup attempt will fail
with pytest.raises(InvalidAddress):
Web3.solidityKeccak(types, values)
# when called as instance method, ens lookups can succeed
actual = web3.solidityKeccak(types, values)
assert actual == expected
def generate_go_ethereum_fixture(destination_dir):
with contextlib.ExitStack() as stack:
datadir = stack.enter_context(tempdir())
keystore_dir = os.path.join(datadir, 'keystore')
ensure_path_exists(keystore_dir)
keyfile_path = os.path.join(keystore_dir, KEYFILE_FILENAME)
with open(keyfile_path, 'w') as keyfile:
keyfile.write(KEYFILE_DATA)
genesis_file_path = os.path.join(datadir, 'genesis.json')
with open(genesis_file_path, 'w') as genesis_file:
genesis_file.write(json.dumps(GENESIS_DATA))
geth_ipc_path_dir = stack.enter_context(tempdir())
geth_ipc_path = os.path.join(geth_ipc_path_dir, 'geth.ipc')
geth_port = get_open_port()
geth_binary = get_geth_binary()
with get_geth_process(geth_binary=geth_binary,
datadir=datadir,
genesis_file_path=genesis_file_path,
geth_ipc_path=geth_ipc_path,
geth_port=geth_port):
wait_for_socket(geth_ipc_path)
web3 = Web3(Web3.IPCProvider(geth_ipc_path))
chain_data = setup_chain_state(web3)
# close geth by exiting context
# must be closed before copying data dir
verify_chain_state(web3, chain_data)
# verify that chain state is still valid after closing
# and re-opening geth
with get_geth_process(geth_binary=geth_binary,
datadir=datadir,
genesis_file_path=genesis_file_path,
geth_ipc_path=geth_ipc_path,
geth_port=geth_port):
wait_for_socket(geth_ipc_path)
web3 = Web3(Web3.IPCProvider(geth_ipc_path))
verify_chain_state(web3, chain_data)
static_data = {
'raw_txn_account': RAW_TXN_ACCOUNT,
'keyfile_pw': KEYFILE_PW,
}
config = merge(chain_data, static_data)
pprint.pprint(config)
write_config_json(config, datadir)
shutil.copytree(datadir, destination_dir)
def test_isConnected_disconnected():
"""
Web3.isConnected() returns False when configured with a provider
that's not connected to a node.
"""
web3 = Web3(DisconnectedProvider())
assert web3.isConnected() is False
def web3(request):
use_filter_middleware = request.param
provider = EthereumTesterProvider()
w3 = Web3(provider)
if use_filter_middleware:
w3.middleware_onion.add(local_filter_middleware)
return w3
def w3(open_port, start_websocket_server):
# need new event loop as the one used by server is already running
event_loop = asyncio.new_event_loop()
endpoint_uri = 'ws://127.0.0.1:{}'.format(open_port)
event_loop.run_until_complete(wait_for_ws(endpoint_uri, event_loop))
provider = WebsocketProvider(endpoint_uri, websocket_timeout=0.01)
return Web3(provider)
def balance(address, rpc):
"""Get the balance of the address"""
web3 = Web3(HTTPProvider(rpc))
a = web3.toChecksumAddress(address)
balance_wei = web3.eth.getBalance(a)
b = web3.fromWei(balance_wei, 'ether')
print("The balance of {} is {} NEW.".format(a, b))
def test_auto_provider_none():
# init without provider succeeds, even when no provider available
w3 = Web3()
# non-node requests succeed
w3.toHex(0) == '0x0'
type(w3.provider) == AutoProvider
def test_labelhash(ens, label, expected_hash):
if isinstance(expected_hash, type):
with pytest.raises(expected_hash):
ens.labelhash(label)
else:
labelhash = ens.labelhash(label)
assert isinstance(labelhash, bytes)
hash_hex = Web3.toHex(labelhash)
assert hash_hex == expected_hash
def bytes32(val):
if isinstance(val, int):
result = Web3.toBytes(val)
else:
raise TypeError('val %r could not be converted to bytes')
if len(result) < 32:
return result.rjust(32, b'\0')
else:
return result
def normal_name_to_hash(name):
node = EMPTY_SHA3_BYTES
if name:
labels = name.split(".")
for label in reversed(labels):
labelhash = label_to_hash(label)
assert isinstance(labelhash, bytes)
assert isinstance(node, bytes)
node = Web3().keccak(node + labelhash)
return node
def convert(address, rpc):
"""Convert address of NEW"""
web3 = Web3(HTTPProvider(rpc))
chain_id = int(web3.net.version)
if utils.is_address(address):
print(hex_to_new(address, chain_id), address)
elif is_new_address(address):
print(address, new_to_hex(address, chain_id))
else:
print("Address invalid")
def generate_go_ethereum_fixture(destination_dir):
with contextlib.ExitStack() as stack:
datadir = stack.enter_context(common.tempdir())
keystore_dir = os.path.join(datadir, 'keystore')
common.ensure_path_exists(keystore_dir)
keyfile_path = os.path.join(keystore_dir, common.KEYFILE_FILENAME)
with open(keyfile_path, 'w') as keyfile:
keyfile.write(common.KEYFILE_DATA)
genesis_file_path = os.path.join(datadir, 'genesis.json')
with open(genesis_file_path, 'w') as genesis_file:
genesis_file.write(json.dumps(common.GENESIS_DATA))
geth_ipc_path_dir = stack.enter_context(common.tempdir())
geth_ipc_path = os.path.join(geth_ipc_path_dir, 'geth.ipc')
geth_port = get_open_port()
geth_binary = common.get_geth_binary()
geth_proc = stack.enter_context(
common.get_geth_process( # noqa: F841
geth_binary=geth_binary,
datadir=datadir,
genesis_file_path=genesis_file_path,
ipc_path=geth_ipc_path,
port=geth_port,
networkid=str(common.GENESIS_DATA['config']['chainId'])))
common.wait_for_socket(geth_ipc_path)
web3 = Web3(Web3.IPCProvider(geth_ipc_path))
chain_data = setup_chain_state(web3)
static_data = {
'raw_txn_account': common.RAW_TXN_ACCOUNT,
'keyfile_pw': common.KEYFILE_PW,
}
pprint.pprint(merge(chain_data, static_data))
shutil.copytree(datadir, destination_dir)
def pay(path, src, dest, value, data, rpc, password):
"""Pay NEW to address"""
web3 = Web3(HTTPProvider(rpc))
src = web3.toChecksumAddress(src)
dest = web3.toChecksumAddress(dest)
value = web3.toWei(value, "ether")
if data is not None:
data = data.encode('utf-8')
else:
data = b''
json_value = get_address_from_wallet(src, path)
if json_value == "":
print("No from address")
return
nonce = web3.eth.getTransactionCount(src)
chain_id = int(web3.net.version)
gas_price = web3.eth.gasPrice
tx = {
'to': dest,
'value': value,
'gas': 0,
'gasPrice': gas_price,
'nonce': nonce,
'chainId': chain_id,
'data': data,
}
gas = web3.eth.estimateGas(tx)
tx['gas'] = gas
if password is None:
password = click.prompt("Enter the password of the keystore",
hide_input=True)
Account.chain_id = chain_id
try:
a = Account.privateKeyToAccount(
Account.decrypt(json_value, password.encode('utf-8')))
sign_tx = a.signTransaction(tx)
tx_hash = web3.eth.sendRawTransaction(sign_tx.rawTransaction)
print(tx_hash.hex())
except ValueError:
print("error")
pass
def test_eth_account_sign_transaction_from_eth_test(acct, transaction_info):
expected_raw_txn = transaction_info['signed']
key = transaction_info['key']
transaction = dissoc(transaction_info, 'signed', 'key', 'unsigned')
# validate r, in order to validate the transaction hash
# There is some ambiguity about whether `r` will always be deterministically
# generated from the transaction hash and private key, mostly due to code
# author's ignorance. The example test fixtures and implementations seem to agree, so far.
# See ecdsa_raw_sign() in /eth_keys/backends/native/ecdsa.py
signed = acct.signTransaction(transaction, key)
assert signed.r == Web3.toInt(hexstr=expected_raw_txn[-130:-66])
# confirm that signed transaction can be recovered to the sender
expected_sender = acct.privateKeyToAccount(key).address
assert acct.recoverTransaction(signed.rawTransaction) == expected_sender
def test_setup_name(ens, name, normalized_name, namehash_hex):
address = ens.web3.eth.accounts[3]
assert not ens.name(address)
owner = ens.owner('tester.eth')
ens.setup_name(name, address)
assert ens.name(address) == normalized_name
# check that the correct namehash is set:
node = Web3.toBytes(hexstr=namehash_hex)
assert ens.resolver(normalized_name).caller.addr(node) == address
# check that the correct owner is set:
assert ens.owner(name) == owner
ens.setup_name(None, address)
ens.setup_address(name, None)
assert not ens.name(address)
assert not ens.address(name)
def test_autoprovider_detection():
def no_provider():
return None
def must_not_call():
assert False
auto = AutoProvider([
no_provider,
DisconnectedProvider,
ConnectedProvider,
must_not_call,
])
w3 = Web3(auto)
assert w3.isConnected()
assert isinstance(auto._active_provider, ConnectedProvider)
def test_set_address(ens, name, full_name, namehash_hex, TEST_ADDRESS):
assert ens.address(name) is None
owner = ens.owner('tester.eth')
ens.setup_address(name, TEST_ADDRESS)
assert is_same_address(ens.address(name), TEST_ADDRESS)
namehash = Web3.toBytes(hexstr=namehash_hex)
normal_name = ens.nameprep(full_name)
assert is_same_address(ens.address(name), TEST_ADDRESS)
# check that the correct namehash is set:
assert is_same_address(
ens.resolver(normal_name).caller.addr(namehash), TEST_ADDRESS)
# check that the correct owner is set:
assert ens.owner(name) == owner
ens.setup_address(name, None)
assert ens.address(name) is None
def blocking_w3():
return Web3(EthereumTesterProvider(),
modules={
'blocking_version': BlockingVersion,
'legacy_version': Version
})
def web3(parity_process, endpoint_uri, event_loop):
event_loop.run_until_complete(wait_for_ws(endpoint_uri, event_loop))
_web3 = Web3(Web3.WebsocketProvider(endpoint_uri))
return _web3
from newchain_web3 import (
Web3,
WebsocketProvider,
)
w3 = Web3(WebsocketProvider())
from newchain_web3 import Web3
from newchain_web3.providers.auto import (
load_provider_from_uri, )
from .endpoints import (
INFURA_MAINNET_DOMAIN,
build_infura_url,
)
_infura_url = build_infura_url(INFURA_MAINNET_DOMAIN)
w3 = Web3(load_provider_from_uri(_infura_url))
#!/usr/bin/env python
# encoding: utf-8
"""
@author: Tang Smith
@software: PyCharm
@time: 2019-04-01 21:51
@copyright: 2018-2019 Newton Foundation. All rights reserved.
"""
import base58
import json
from newchain_web3 import Web3, HTTPProvider
w3 = Web3(HTTPProvider('https://rpc1.newchain.newtonproject.org/'))
ClientVersion = int(w3.net.version)
print("Client Version: %s" % ClientVersion)
from web3.middleware import geth_poa_middleware
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
def NewToEth(str):
print("Str: 0x%s" % base58.b58decode_check(str[3:]).hex().lower()[6:])
return "0x%s" % base58.b58decode_check(str[3:]).hex().lower()[6:]
From = w3.toChecksumAddress(
NewToEth("NEW17zDT6sQYPCATtJZ3QpPoR2yW8aGBc2hS3MT")) #/tmp/wallet
To = w3.toChecksumAddress(NewToEth("NEW17zNNCR9ouLnVMktE8iHBwaPZJh14iK3ghGU"))
print("Gas Price: %s" % w3.eth.gasPrice)
from newchain_web3 import Web3 w3 = Web3()
from newchain_web3 import (
IPCProvider,
Web3,
)
w3 = Web3(IPCProvider())
from newchain_web3 import (
HTTPProvider,
Web3,
)
w3 = Web3(HTTPProvider())
def fresh_w3():
w3 = Web3(Web3.EthereumTesterProvider())
w3.eth.defaultAccount = w3.eth.accounts[0]
w3.eth.defaultContractFactory = LinkableContract
w3.enable_unstable_package_management_api()
return w3
def w3_base():
return Web3(provider=DummyProvider(), middlewares=[])
def async_w3():
return Web3(AsyncEthereumTesterProvider(),
middlewares=[],
modules={
'async_version': AsyncVersion,
})
