def connect(network, account='user'):
if network == 'local':
from web3 import Web3
w3 = Web3(Web3.HTTPProvider("http://127.0.0.1:8545"))
try:
w3.eth.defaultAccount = w3.eth.accounts[0]
admin = w3.eth.accounts[0]
except:
raise Exception("Ensure ganache-cli is connected")
elif network == 'bsc-testnet':
config = read_config()
os.environ[
'WEB3_PROVIDER_URI'] = 'https://data-seed-prebsc-1-s1.binance.org:8545/'
os.environ['WEB3_CHAIN_ID'] = '97'
from web3.middleware import construct_sign_and_send_raw_middleware
from web3.middleware import geth_poa_middleware
from web3.auto import w3
admin = w3.eth.account.from_key(config[account]['key'])
w3.eth.defaultAccount = admin.address
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(admin))
elif network == 'bsc-mainnet':
config = read_config()
os.environ['WEB3_PROVIDER_URI'] = 'https://bsc-dataseed.binance.org/'
os.environ['WEB3_CHAIN_ID'] = '56'
from web3.middleware import construct_sign_and_send_raw_middleware
from web3.middleware import geth_poa_middleware
from web3.auto import w3
admin = w3.eth.account.from_key(config[account]['key'])
w3.eth.defaultAccount = admin.address
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(admin))
elif network == 'kovan':
config = read_config()
os.environ['WEB3_INFURA_PROJECT_ID'] = config['infura']['project_id']
os.environ['WEB3_INFURA_API_SECRET'] = config['infura']['secret']
from web3.middleware import construct_sign_and_send_raw_middleware
from web3.auto.infura.kovan import w3
admin = w3.eth.account.from_key(config[account]['key'])
w3.eth.defaultAccount = admin.address
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(admin))
else:
raise ValueError(f'Unknown network {network}')
assert w3.isConnected()
return w3, admin
def test_sign_and_send_raw_middleware_with_byte_addresses(
w3_dummy,
from_converter,
to_converter):
private_key = PRIVATE_KEY_1
from_ = from_converter(ADDRESS_1)
to_ = to_converter(ADDRESS_2)
w3_dummy.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key))
actual = w3_dummy.manager.request_blocking(
'eth_sendTransaction',
[{
'to': to_,
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
raw_txn = actual[1][0]
actual_method = actual[0]
assert actual_method == 'eth_sendRawTransaction'
assert isinstance(raw_txn, bytes)
def __init__(
self,
web3: Web3,
private_key: str,
gas_limit: int,
gas_price: int = 1,
wait: int = 10,
contracts_version: Optional[str] = None,
):
# pylint: disable=E1101
super(ContractDeployer, self).__init__(web3=web3, contracts_version=contracts_version)
self.wait = wait
self.owner = private_key_to_address(private_key)
self.transaction = {"from": self.owner, "gas": gas_limit}
if gas_price != 0:
self.transaction["gasPrice"] = gas_price * int(units["gwei"])
self.web3.middleware_stack.add(construct_sign_and_send_raw_middleware(private_key))
# Check that the precompiled data matches the source code
# Only for current version, because this is the only one with source code
if self.contracts_version in [None, CONTRACTS_VERSION]:
contract_manager_source = ContractSourceManager(contracts_source_path())
contract_manager_source.checksum_contracts()
contract_manager_source.verify_precompiled_checksums(self.precompiled_path)
else:
LOG.info("Skipped checks against the source code because it is not available.")
def make_web3_provider(self, account):
w3 = Web3(HTTPProvider(self.url))
w3.middleware_stack.add(
construct_sign_and_send_raw_middleware(account.private_key))
w3.middleware_stack.inject(geth_poa_middleware, layer=0)
return w3
def __init__(
self,
web3: Web3,
private_key: str,
gas_limit: int,
gas_price: int=1,
wait: int=10,
contracts_version: Optional[str]=None,
):
self.web3 = web3
self.wait = wait
self.owner = private_key_to_address(private_key)
self.transaction = {'from': self.owner, 'gas': gas_limit}
if gas_price != 0:
self.transaction['gasPrice'] = gas_price * denoms.gwei
self.contracts_version = contracts_version
self.precompiled_path = contracts_precompiled_path(self.contracts_version)
self.contract_manager = ContractManager(self.precompiled_path)
self.web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key),
)
# Check that the precompiled data matches the source code
# Only for current version, because this is the only one with source code
if self.contracts_version in [None, CONTRACTS_VERSION]:
contract_manager_source = ContractManager(contracts_source_path())
contract_manager_source.checksum_contracts()
contract_manager_source.verify_precompiled_checksums(self.precompiled_path)
else:
log.info('Skipped checks against the source code because it is not available.')
def get_web3_client(network: str) -> Web3:
"""Returns instance of the Web3 client."""
network_config = NETWORKS[network]
endpoint = network_config["KEEPER_ETH1_ENDPOINT"]
# Prefer WS over HTTP
if endpoint.startswith("ws"):
w3 = Web3(Web3.WebsocketProvider(endpoint, websocket_timeout=60))
logger.warning(f"[{network}] Web3 websocket endpoint={endpoint}")
elif endpoint.startswith("http"):
w3 = Web3(Web3.HTTPProvider(endpoint))
logger.warning(f"[{network}] Web3 HTTP endpoint={endpoint}")
else:
w3 = Web3(Web3.IPCProvider(endpoint))
logger.warning(f"[{network}] Web3 HTTP endpoint={endpoint}")
if network_config["IS_POA"]:
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
logger.warning(f"[{network}] Injected POA middleware")
account = w3.eth.account.from_key(network_config["ORACLE_PRIVATE_KEY"])
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(account))
logger.warning(
f"[{network}] Injected middleware for capturing transactions and sending as raw"
)
w3.eth.default_account = account.address
logger.info(f"[{network}] Configured default account {w3.eth.default_account}")
return w3
def test_sign_and_send_raw_middleware_with_byte_addresses(
w3_dummy,
from_converter,
to_converter):
private_key = PRIVATE_KEY_1
from_ = from_converter(ADDRESS_1)
to_ = to_converter(ADDRESS_2)
w3_dummy.middleware_onion.add(
construct_sign_and_send_raw_middleware(private_key))
actual = w3_dummy.manager.request_blocking(
'eth_sendTransaction',
[{
'to': to_,
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
raw_txn = actual[1][0]
actual_method = actual[0]
assert actual_method == 'eth_sendRawTransaction'
assert isinstance(raw_txn, bytes)
def register_private_key(web3: Web3, private_key):
assert (isinstance(web3, Web3))
account = Account.privateKeyToAccount(private_key)
_registered_accounts[(web3, Address(account.address))] = account
web3.middleware_onion.add(construct_sign_and_send_raw_middleware(account))
def make_web3_provider(url: str, account: Account) -> Web3:
w3 = Web3(HTTPProvider(url))
w3.middleware_onion.add(simple_cache_middleware)
if is_infura(w3):
# Infura sometimes erroneously returns `null` for existing (but very recent) blocks.
# Work around this by retrying those requests.
# See docstring for details.
Eth.getBlock = make_patched_web3_get_block(Eth.getBlock) # type: ignore
def gas_price_strategy_eth_gas_station_or_with_margin(web3: Web3, transaction_params):
# FIXME: This is a temporary fix to speed up gas price generation
# by fetching from eth_gas_station if possible.
# Once we have a reliable gas price calculation this can be removed
try:
response = requests.get(ETH_GAS_STATION_API)
if response and response.status_code == 200:
data = response.json()
log.debug(f"fetched gas price: {Wei(int(data['fast'] * 10e7 * 1.1))} Wei")
return Wei(int(data["fast"] * 10e7 * 1.1))
except (TimeoutError, ConnectionError, KeyError):
log.debug("Could not fetch from ethgasstation. Falling back to web3 gas estimation.")
gas_price_strategy = construct_time_based_gas_price_strategy(
max_wait_seconds=15, sample_size=25
)
gas_price = Wei(int(gas_price_strategy(web3, transaction_params) * GAS_PRICE_MARGIN))
return gas_price
w3.eth.setGasPriceStrategy(gas_price_strategy_eth_gas_station_or_with_margin)
if account.passphrase is not None:
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(account.private_key))
w3.middleware_onion.inject(make_sane_poa_middleware, layer=0)
return w3
def connect(contract_names=None, get_related=True):
config, contract_details = read_config(contracts=contract_names,
get_related=get_related)
os.environ['WEB3_INFURA_PROJECT_ID'] = config['infura']['project_id']
os.environ['WEB3_INFURA_API_SECRET'] = config['infura']['secret']
if config['infura']['network'] == 'kovan':
from web3.auto.infura.kovan import w3
else:
from web3.auto.infura import w3
assert w3.isConnected()
market_maker = w3.eth.account.from_key(config['maker']['key'])
w3.middleware_onion.add(
construct_sign_and_send_raw_middleware(market_maker))
w3.eth.defaultAccount = market_maker.address
contracts = {
name: w3.eth.contract(address=contract_details[name]['address'],
abi=contract_details[name]['abi'])
for name in contract_details
}
return w3, contracts
def test_sign_and_send_raw_middleware(w3_dummy, w3, method, from_, expected,
key_object):
w3_dummy.middleware_onion.add(
construct_sign_and_send_raw_middleware(key_object))
if isinstance(expected, type) and issubclass(expected, Exception):
with pytest.raises(expected):
w3_dummy.manager.request_blocking(method, [{
'to': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
else:
actual = w3_dummy.manager.request_blocking(method, [{
'to': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
raw_txn = actual[1][0]
actual_method = actual[0]
assert actual_method == expected
assert isinstance(raw_txn, bytes)
def connect():
from web3.auto import w3
from web3.middleware import construct_sign_and_send_raw_middleware
admin = w3.eth.account.from_key('')
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(admin))
w3.eth.defaultAccount = admin.address
return w3, admin
def make_web3_provider(url: str, account: Account) -> Web3:
w3 = Web3(HTTPProvider(url))
w3.eth.setGasPriceStrategy(fast_gas_price_strategy)
w3.middleware_onion.add(
construct_sign_and_send_raw_middleware(account.private_key))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
return w3
def login_and_mint(private_key, filename):
account = Account.from_key(private_key)
w3 = Web3(Web3.WebsocketProvider(os.getenv("INFURA_URL")))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(account))
w3.eth.default_account = account.address
contract = w3.eth.contract(address=os.getenv("ZORA_CONTRACT_ADDRESS"),
abi=get_abi())
mint('pokemon-gpt-2-output' + '/' + filename, contract, w3)
def test_raw_transaction_address_as_string(greeter, web3, private_key_account,
private_key_hex):
# This works: Sending a transaction using the raw transaction middleware if 'from' is a hex string
web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key_hex))
greeter.functions.payForNothing().transact({
'value': 100,
'from': private_key_account,
})
def __init__(
self, rpc_url: URI, private_key: Path, password: Optional[Path] = None, wait: int = 10
):
self.web3 = Web3(HTTPProvider(rpc_url))
self.private_key = get_private_key(private_key, password)
assert self.private_key is not None
self.owner = private_key_to_address(self.private_key)
self.wait = wait
self.web3.middleware_onion.add(construct_sign_and_send_raw_middleware(self.private_key))
self.web3.eth.defaultAccount = self.owner # type: ignore
self.web3.middleware_onion.inject(geth_poa_middleware, layer=0)
def main(
private_key: str,
state_db: str, # pylint: disable=unused-argument
web3: Web3,
contracts: Dict[str, Contract],
start_block: BlockNumber, # pylint: disable=unused-argument
service_url: str,
) -> None:
"""
Registers the address of a service deployment with the `ServiceRegistry`.
The address that is registered is derived from the supplied private key.
It also sets or updates the URL of the services deployment.
"""
# Add middleware to sign transactions by default
web3.middleware_stack.add(construct_sign_and_send_raw_middleware(private_key))
service_address = private_key_to_address(private_key)
log.info("Running service registration script", account_address=service_address)
service_registry_contract = contracts[CONTRACT_SERVICE_REGISTRY]
# check if already registered
currently_registered = service_registry_contract.functions.hasValidRegistration(
service_address
).call()
current_url = service_registry_contract.functions.urls(service_address).call()
log.info(
"Current ServiceRegistry information for service address",
service_address=service_address,
currently_registered=currently_registered,
current_url=current_url,
)
# Register if not yet done
if not currently_registered:
deposit_to_registry(
web3=web3,
service_registry_contract=service_registry_contract,
user_deposit_contract=contracts[CONTRACT_USER_DEPOSIT],
service_address=service_address,
)
update_service_url(
web3=web3,
service_registry_contract=service_registry_contract,
service_address=service_address,
service_url=service_url,
current_url=current_url,
)
current_url = service_registry_contract.functions.urls(service_address).call()
log.info("Updated infos", current_url=current_url)
def _check_account_from_key(self):
try:
account = Account()
acct = account.from_key(config.PAYER_KEY)
self._web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(acct))
self._payer_account = Address(acct.address)
except:
self._logger.fatal(f"Account {config.PAYER_ADDRESS} register key error")
return False
return True
def test_raw_transaction_address_as_bytes(greeter, web3, private_key_account,
private_key_hex):
# This doesn't work: Sending a transaction using the raw transaction middleware if 'from' is bytes
# (instead, with eth_tester it raises AccountLocked)
web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key_hex))
private_key_account_as_bytes = to_bytes(hexstr=private_key_account)
greeter.functions.payForNothing().transact({
'value':
100,
'from':
private_key_account_as_bytes,
})
def test_raw_transaction_address_as_bytes_inject_layer_0(
greeter, web3, private_key_account, private_key_hex):
# This doesn't work: passing from as bytes address when injecting raw transaction middleware to layer 0
# (different error than test_raw_transaction_address_as_bytes)
web3.middleware_stack.inject(
construct_sign_and_send_raw_middleware(private_key_hex), layer=0)
private_key_account_as_bytes = to_bytes(hexstr=private_key_account)
greeter.functions.payForNothing().transact({
'value':
100,
'from':
private_key_account_as_bytes,
})
def web3_foreign(node_foreign, accounts, account_keys):
web3 = Web3(HTTPProvider(FOREIGN_RPC_URL))
web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(account_keys))
for account in accounts[1:]:
wait_for_successful_transaction_receipt(
web3,
web3.eth.sendTransaction({
"from": accounts[0],
"to": account,
"value": START_WEI_PER_ACCOUNT
}),
)
return web3
def __init__( # pylint: disable=too-many-arguments
self,
web3: Web3,
private_key: PrivateKey,
db_filename: str,
contracts: Dict[str, Contract],
sync_start_block: BlockNumber,
required_confirmations: BlockTimeout,
poll_interval: float,
min_reward: int = 0,
get_timestamp_now: Callable = get_posix_utc_time_now,
):
self.web3 = web3
self.chain_id = ChainID(web3.eth.chain_id)
self.private_key = private_key
self.address = private_key_to_address(private_key)
self.poll_interval = poll_interval
self.service_registry = contracts[CONTRACT_SERVICE_REGISTRY]
self.token_network_registry = contracts[
CONTRACT_TOKEN_NETWORK_REGISTRY]
self.get_timestamp_now = get_timestamp_now
self.try_scheduled_events_after = get_timestamp_now()
web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(private_key))
monitoring_contract = contracts[CONTRACT_MONITORING_SERVICE]
user_deposit_contract = contracts[CONTRACT_USER_DEPOSIT]
self.database = Database(
filename=db_filename,
chain_id=self.chain_id,
registry_address=to_canonical_address(
self.token_network_registry.address),
receiver=self.address,
msc_address=MonitoringServiceAddress(
to_canonical_address(monitoring_contract.address)),
sync_start_block=sync_start_block,
)
ms_state = self.database.load_state()
self.context = Context(
ms_state=ms_state,
database=self.database,
web3=self.web3,
monitoring_service_contract=monitoring_contract,
user_deposit_contract=user_deposit_contract,
min_reward=min_reward,
required_confirmations=required_confirmations,
)
def withdraw_cmd(
private_key: str,
state_db: str, # pylint: disable=unused-argument
web3: Web3,
contracts: Dict[str, Contract],
start_block: BlockNumber,
to: Optional[Address],
) -> None:
"""
Withdraw tokens deposited to the ServiceRegistry.
"""
# Add middleware to sign transactions by default
web3.middleware_onion.add(construct_sign_and_send_raw_middleware(private_key))
withdraw(private_key, web3, contracts, start_block, to)
def _check_keeper_account(self):
with open(config.KEEPER_KEY_FILE) as f:
read_key = f.read().replace("\n","")
# check account with key
try:
account = Account()
acct = account.from_key(read_key)
self.web3.middleware_onion.add(construct_sign_and_send_raw_middleware(acct))
self.keeper_account = Address(acct.address)
self.keeper_account_key = read_key
except Exception as e:
self.logger.warning(f"check private key error: {e}")
return False
return True
def connect():
credentials = json.loads(os.environ.get('CREDENTIALS'))
os.environ['WEB3_INFURA_PROJECT_ID'] = credentials['infura']['project_id']
os.environ['WEB3_INFURA_API_SECRET'] = credentials['infura']['secret']
if credentials['infura']['network'] == 'kovan':
from web3.auto.infura.kovan import w3
else:
from web3.auto.infura import w3
assert w3.isConnected()
acct = w3.eth.account.from_key(credentials['mainnet']['key'])
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(acct))
w3.eth.defaultAccount = acct.address
return w3
def get_votes_from_blochchain(spec_hash):
w3 = Web3(Web3.HTTPProvider(PROVIDER_HTTP_ENDPOINT))
acct = Account.from_key(PRIVATE_KEY)
abi = json.load(open("voting.json"))
VotingAlpha = w3.eth.contract(address=CONTRACT_ADDRESS, abi=abi)
w3.middleware_onion.add(
construct_sign_and_send_raw_middleware(acct.privateKey))
print(spec_hash)
p_id = VotingAlpha.functions.getProposalId(spec_hash.replace("0x0x",
"0x")).call()
proposalInfo = VotingAlpha.functions.getProposal(p_id).call()
print("No votes:", proposalInfo[3])
print("Yes votes:", proposalInfo[4])
return (proposalInfo[4], proposalInfo[3])
def main(rpc_url: URI, private_key: Path, token_address: ChecksumAddress, amount: int) -> None:
web3 = Web3(HTTPProvider(rpc_url))
privkey = get_private_key(private_key)
assert privkey is not None
owner = private_key_to_address(privkey)
web3.middleware_onion.add(construct_sign_and_send_raw_middleware(privkey))
token_code = web3.eth.get_code(token_address, "latest")
assert token_code != HexBytes("")
token_contract = ContractManager(contracts_precompiled_path()).get_contract(
CONTRACT_CUSTOM_TOKEN
)
token_proxy = web3.eth.contract(address=token_address, abi=token_contract["abi"])
tx_hash = token_proxy.functions.mint(amount).transact({"from": owner})
print(f"Minting tokens for address {owner}")
print(f"Transaction hash {encode_hex(tx_hash)}")
balance = token_proxy.functions.balanceOf(owner).call()
print(f"Balance of {owner}: {balance}")
def initialize(self, account, estimate_gas_only=False):
# to make it easier to deploy and interact with the contract, tell Web3 to use a specific account
# when sending transactions
if account:
self.simple_web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(account))
self.simple_web3.eth.default_account = account.address
# load ABI from file if it was supplied
if self.abi_filepath and os.path.exists(self.abi_filepath):
print(f'Loading ABI from {self.abi_filepath}')
with open(self.abi_filepath) as f:
self.abi = json.load(f)
# load bytecode from file if it was supplied
if self.bytecode_filepath and os.path.exists(self.bytecode_filepath):
print(f'Loading bytecode from {self.bytecode_filepath}')
with open(self.bytecode_filepath) as f:
self.bytecode = f.read()
# if we couldn't load the ABI then we need to compile ourselves
if not self.abi:
self.compile()
# if an address was supplied then use that to initialize the contract
if self.address:
print(f'Loading existing contract at address {self.address}')
self.contract = self.simple_web3.eth.contract(address=self.address,
abi=self.abi)
print(f'Existing contract with address {self.address} initialized')
# otherwise we need to deploy a new contract
else:
print(f'Deploying new contract {self.name}')
self.deploy(estimate_gas_only=estimate_gas_only)
if not estimate_gas_only:
# sometimes there is a delay after deploying a contract so we
# need to wait until its for sure available
code = self.simple_web3.eth.getCode(self.address)
while code in ['0x', '0x0']:
print('contract not found? waiting...')
time.sleep(1)
print('New contract initialized')
def __init__( # pylint: disable=too-many-arguments
self,
web3: Web3,
private_key: str,
db_filename: str,
contracts: Dict[str, Contract],
sync_start_block: BlockNumber = BlockNumber(0),
required_confirmations: int = DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
poll_interval: float = 1,
min_reward: int = 0,
):
self.web3 = web3
self.private_key = private_key
self.address = private_key_to_address(private_key)
self.required_confirmations = required_confirmations
self.poll_interval = poll_interval
self.service_registry = contracts[CONTRACT_SERVICE_REGISTRY]
web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key))
monitoring_contract = contracts[CONTRACT_MONITORING_SERVICE]
user_deposit_contract = contracts[CONTRACT_USER_DEPOSIT]
chain_id = ChainID(int(web3.net.version))
self.database = Database(
filename=db_filename,
chain_id=chain_id,
registry_address=contracts[CONTRACT_TOKEN_NETWORK_REGISTRY].
address,
receiver=self.address,
msc_address=monitoring_contract.address,
sync_start_block=sync_start_block,
)
ms_state = self.database.load_state()
self.context = Context(
ms_state=ms_state,
db=self.database,
web3=self.web3,
monitoring_service_contract=monitoring_contract,
user_deposit_contract=user_deposit_contract,
min_reward=min_reward,
required_confirmations=required_confirmations,
)
def test_raw_transaction_contract_address_as_bytes(greeter, web3,
private_key_account,
private_key_hex):
# This doesn't work: passing contract address as bytes when USING raw transaction middleware
web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key_hex))
greeter_address_bytes = to_bytes(hexstr=greeter.address)
assert to_checksum_address(
greeter_address_bytes) == greeter.address # sanity check
wrapped_greeter = web3.eth.contract(address=greeter_address_bytes,
abi=greeter.abi)
wrapped_greeter.functions.payForNothing().transact({
'value':
100,
'from':
private_key_account,
})
def test_signed_transaction(w3, fund_account, transaction, expected,
key_object, from_):
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(key_object))
# Drop any falsy addresses
to_from = valfilter(bool, {'to': w3.eth.accounts[0], 'from': from_})
_transaction = merge(transaction, to_from)
if isinstance(expected, type) and issubclass(expected, Exception):
with pytest.raises(expected):
w3.eth.send_transaction(_transaction)
else:
start_balance = w3.eth.get_balance(
_transaction.get('from', w3.eth.accounts[0]))
w3.eth.send_transaction(_transaction)
assert w3.eth.get_balance(
_transaction.get('from')) <= start_balance + expected
def test_signed_transaction(
w3,
fund_account,
transaction,
expected,
key_object,
from_):
w3.middleware_stack.add(construct_sign_and_send_raw_middleware(key_object))
# Drop any falsy addresses
to_from = valfilter(bool, {'to': w3.eth.accounts[0], 'from': from_})
_transaction = merge(transaction, to_from)
if isinstance(expected, type) and issubclass(expected, Exception):
with pytest.raises(expected):
start_balance = w3.eth.getBalance(_transaction.get('from', w3.eth.accounts[0]))
w3.eth.sendTransaction(_transaction)
else:
start_balance = w3.eth.getBalance(_transaction.get('from', w3.eth.accounts[0]))
w3.eth.sendTransaction(_transaction)
assert w3.eth.getBalance(_transaction.get('from')) <= start_balance + expected
def test_sign_and_send_raw_middleware(
w3_dummy,
w3,
method,
from_,
expected,
key_object):
w3_dummy.middleware_stack.add(
construct_sign_and_send_raw_middleware(key_object))
if isinstance(expected, type) and issubclass(expected, Exception):
with pytest.raises(expected):
w3_dummy.manager.request_blocking(
method,
[{
'to': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
else:
actual = w3_dummy.manager.request_blocking(
method,
[{
'to': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
'from': from_,
'gas': 21000,
'gasPrice': 0,
'value': 1,
'nonce': 0
}])
raw_txn = actual[1][0]
actual_method = actual[0]
assert actual_method == expected
assert isinstance(raw_txn, bytes)
