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.sign_transaction(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.from_key(key).address
assert acct.recover_transaction(signed.rawTransaction) == expected_sender
def mine_blocks(self, num_blocks=1, coinbase=None):
for _ in range(num_blocks):
block_to_mine = dissoc(self.block, 'hash')
block_hash = fake_rlp_hash(block_to_mine)
mined_block = assoc(block_to_mine, 'hash', block_hash)
assign_block_info = compose(
partial(assoc, key='block_number', value=mined_block['number']),
partial(assoc, key='block_hash', value=mined_block['hash']),
)
mined_block['transactions'] = tuple(
assign_block_info(transaction)
for transaction
in mined_block['transactions']
)
self.blocks.append(mined_block)
self.block = make_block_from_parent(mined_block)
yield block_hash
def test_build_transaction_with_contract_with_arguments(
web3, skip_if_testrpc, math_contract, transaction_args, method_args,
method_kwargs, expected, skip_testrpc, buildTransaction):
if skip_testrpc:
skip_if_testrpc(web3)
txn = buildTransaction(contract=math_contract,
contract_function='increment',
func_args=method_args,
func_kwargs=method_kwargs,
tx_params=transaction_args)
expected['to'] = math_contract.address
assert txn is not None
if 'gas' in transaction_args:
assert txn['gas'] == transaction_args['gas']
else:
assert 'gas' in txn
assert dissoc(txn, 'gas') == expected
def test_build_transaction_with_contract_class_method(
w3,
MathContract,
math_contract,
build_transaction):
txn = build_transaction(
contract=MathContract,
contract_function='increment',
tx_params={'to': math_contract.address},
)
assert dissoc(txn, 'gas') == {
'to': math_contract.address,
'data': '0xd09de08a',
'value': 0,
'maxFeePerGas': 2750000000,
'maxPriorityFeePerGas': 10 ** 9,
'chainId': 131277322940537,
}
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
result = make_request(method, params)
# As of v1.8, Geth returns errors when you request a
# receipt for a transaction that is not in the chain.
# It used to return a result of None, so we simulate the old behavior.
if method == "eth_getTransactionReceipt" and "error" in result:
is_geth = str(web3.clientVersion).startswith("Geth")
if is_geth and result["error"]["code"] == -32000:
return assoc(
dissoc(result, "error"),
"result",
None,
)
else:
return result
else:
return result
def middleware(method, params):
result = make_request(method, params)
# As of v1.8, Geth returns errors when you request a
# receipt for a transaction that is not in the chain.
# It used to return a result of None, so we simulate the old behavior.
if method == 'eth_getTransactionReceipt' and 'error' in result:
is_geth = web3.clientVersion.startswith('Geth')
if is_geth and result['error']['code'] == -32000:
return assoc(
dissoc(result, 'error'),
'result',
None,
)
else:
return result
else:
return result
def build_transaction(self, *args: Tuple) -> SignedTransaction:
args, tx = _get_tx(args)
if not tx["from"]:
raise AttributeError(
"Final argument must be a dict of transaction parameters that "
"includes a `from` field specifying the sender of the transaction"
)
if "chainId" not in tx:
# defaults to chainId = 1
tx.update({"chainId": 1})
if "gas" not in tx:
raise AttributeError("we need 'gas' parameter.")
if "gasPrice" not in tx:
raise AttributeError("we need 'gasPrice' parameter.")
if "nonce" not in tx:
raise AttributeError("we need 'nonce' parameter.")
tx.update({"to": self._address, "data": self.encode_input(*args)})
account = tx["from"]
signed_txn = account.sign_transaction(dissoc(tx, 'from'))
return signed_txn
def transaction_normalizer(transaction):
return dissoc(transaction, 'chainId')
def _transaction_normalizer(transaction: TxParams) -> TxParams:
return dissoc(transaction, 'chainId')
def remove_key_if(key, remove_if, input_dict):
if key in input_dict and remove_if(input_dict):
return dissoc(input_dict, key)
else:
return input_dict
def send_signed_transaction(self, signed_transaction):
transaction = dissoc(signed_transaction, 'r', 's', 'v')
return self.send_transaction(transaction)
def remove_key_if(key: Any, remove_if: Callable[[Dict[Any, Any]], bool],
input_dict: Dict[Any, Any]) -> Dict[Any, Any]:
if key in input_dict and remove_if(input_dict):
return dissoc(input_dict, key)
else:
return input_dict
def uninstall_from_ethpm_lock(package_name: str, ethpm_lock: Path) -> None:
old_lock = json.loads(ethpm_lock.read_text())
new_lock = dissoc(old_lock, package_name)
with atomic_replace(ethpm_lock) as ethpm_lock_file:
ethpm_lock_file.write(json.dumps(new_lock, sort_keys=True, indent=4))
ethpm_lock_file.write("\n")
"to": BURN_ADDRESS,
"gas_price": NON_DEFAULT_GAS_PRICE,
"value": 0,
"gas": 21000,
}
TRANSACTION_WTH_NONCE = assoc(SIMPLE_TRANSACTION, 'nonce', 0)
CONTRACT_TRANSACTION_EMPTY_TO = {
"to": '',
"gas_price": NON_DEFAULT_GAS_PRICE,
"value": 0,
"gas": 100000,
}
CONTRACT_TRANSACTION_MISSING_TO = dissoc(CONTRACT_TRANSACTION_EMPTY_TO, 'to')
BLOCK_KEYS = {
"number",
"hash",
"parent_hash",
"nonce",
"sha3_uncles",
"logs_bloom",
"transactions_root",
"receipts_root",
"state_root",
"miner",
"difficulty",
"total_difficulty",
"size",
