From 09f7114b63d65ad4fa369f35f365d8e94a623f8c Mon Sep 17 00:00:00 2001 From: Hsiao-Wei Wang Date: Mon, 27 May 2019 13:15:10 +0800 Subject: [PATCH] copied from deposit contract --- deposit_contract/contracts/__init__.py | 0 deposit_contract/contracts/utils.py | 16 ++ .../contracts/validator_registration.json | 1 + .../contracts/validator_registration.v.py | 138 +++++++++++ deposit_contract/requirements-testing.txt | 7 + deposit_contract/tests/__init__.py | 0 deposit_contract/tests/contracts/__init__.py | 0 deposit_contract/tests/contracts/conftest.py | 111 +++++++++ .../tests/contracts/test_compile.py | 18 ++ .../tests/contracts/test_deposit.py | 221 ++++++++++++++++++ deposit_contract/tests/core/conftest.py | 0 deposit_contract/tests/core/test_import.py | 4 + .../tool/compile_deposit_contract.py | 33 +++ 13 files changed, 549 insertions(+) create mode 100644 deposit_contract/contracts/__init__.py create mode 100644 deposit_contract/contracts/utils.py create mode 100644 deposit_contract/contracts/validator_registration.json create mode 100644 deposit_contract/contracts/validator_registration.v.py create mode 100644 deposit_contract/requirements-testing.txt create mode 100644 deposit_contract/tests/__init__.py create mode 100644 deposit_contract/tests/contracts/__init__.py create mode 100644 deposit_contract/tests/contracts/conftest.py create mode 100644 deposit_contract/tests/contracts/test_compile.py create mode 100644 deposit_contract/tests/contracts/test_deposit.py create mode 100644 deposit_contract/tests/core/conftest.py create mode 100644 deposit_contract/tests/core/test_import.py create mode 100644 deposit_contract/tool/compile_deposit_contract.py diff --git a/deposit_contract/contracts/__init__.py b/deposit_contract/contracts/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/deposit_contract/contracts/utils.py b/deposit_contract/contracts/utils.py new file mode 100644 index 000000000..2aa42ecd3 --- /dev/null +++ b/deposit_contract/contracts/utils.py @@ -0,0 +1,16 @@ +import json +import os + +DIR = os.path.dirname(__file__) + + +def get_deposit_contract_code(): + file_path = os.path.join(DIR, './validator_registration.v.py') + deposit_contract_code = open(file_path).read() + return deposit_contract_code + + +def get_deposit_contract_json(): + file_path = os.path.join(DIR, './validator_registration.json') + deposit_contract_json = open(file_path).read() + return json.loads(deposit_contract_json) diff --git a/deposit_contract/contracts/validator_registration.json b/deposit_contract/contracts/validator_registration.json new file mode 100644 index 000000000..253eedf6d --- /dev/null +++ b/deposit_contract/contracts/validator_registration.json @@ -0,0 +1 @@ +{"abi": [{"name": "Deposit", "inputs": [{"type": "bytes", "name": "pubkey", "indexed": false}, {"type": "bytes", "name": "withdrawal_credentials", "indexed": false}, {"type": "bytes", "name": "amount", "indexed": false}, {"type": "bytes", "name": "signature", "indexed": false}, {"type": "bytes", "name": "merkle_tree_index", "indexed": false}], "anonymous": false, "type": "event"}, {"name": "Eth2Genesis", "inputs": [{"type": "bytes32", "name": "deposit_root", "indexed": false}, {"type": "bytes", "name": "deposit_count", "indexed": false}, {"type": "bytes", "name": "time", "indexed": false}], "anonymous": false, "type": "event"}, {"outputs": [], "inputs": [], "constant": false, "payable": false, "type": "constructor"}, {"name": "to_little_endian_64", "outputs": [{"type": "bytes", "name": "out"}], "inputs": [{"type": "uint256", "name": "value"}], "constant": true, "payable": false, "type": "function", "gas": 7077}, {"name": "from_little_endian_64", "outputs": [{"type": "uint256", "name": "out"}], "inputs": [{"type": "bytes", "name": "value"}], "constant": true, "payable": false, "type": "function", "gas": 5983}, {"name": "get_deposit_root", "outputs": [{"type": "bytes32", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 79251}, {"name": "get_deposit_count", "outputs": [{"type": "bytes", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 11056}, {"name": "deposit", "outputs": [], "inputs": [{"type": "bytes", "name": "pubkey"}, {"type": "bytes", "name": "withdrawal_credentials"}, {"type": "bytes", "name": "signature"}], "constant": false, "payable": true, "type": "function", "gas": 456517}, {"name": "chainStarted", "outputs": [{"type": "bool", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 633}], "bytecode": "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"} \ No newline at end of file diff --git a/deposit_contract/contracts/validator_registration.v.py b/deposit_contract/contracts/validator_registration.v.py new file mode 100644 index 000000000..751d3a2e8 --- /dev/null +++ b/deposit_contract/contracts/validator_registration.v.py @@ -0,0 +1,138 @@ +MIN_DEPOSIT_AMOUNT: constant(uint256) = 1000000000 # Gwei +FULL_DEPOSIT_AMOUNT: constant(uint256) = 32000000000 # Gwei +CHAIN_START_FULL_DEPOSIT_THRESHOLD: constant(uint256) = 65536 # 2**16 +DEPOSIT_CONTRACT_TREE_DEPTH: constant(uint256) = 32 +SECONDS_PER_DAY: constant(uint256) = 86400 +MAX_64_BIT_VALUE: constant(uint256) = 18446744073709551615 # 2**64 - 1 + +Deposit: event({ + pubkey: bytes[48], + withdrawal_credentials: bytes[32], + amount: bytes[8], + signature: bytes[96], + merkle_tree_index: bytes[8], +}) +Eth2Genesis: event({deposit_root: bytes32, deposit_count: bytes[8], time: bytes[8]}) + +zerohashes: bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] +branch: bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] +deposit_count: uint256 +full_deposit_count: uint256 +chainStarted: public(bool) + + +@public +def __init__(): + for i in range(DEPOSIT_CONTRACT_TREE_DEPTH - 1): + self.zerohashes[i+1] = sha256(concat(self.zerohashes[i], self.zerohashes[i])) + self.branch[i+1] = self.zerohashes[i + 1] + + +@public +@constant +def to_little_endian_64(value: uint256) -> bytes[8]: + assert value <= MAX_64_BIT_VALUE + + # array access for bytes[] not currently supported in vyper so + # reversing bytes using bitwise uint256 manipulations + y: uint256 = 0 + x: uint256 = value + for i in range(8): + y = shift(y, 8) + y = y + bitwise_and(x, 255) + x = shift(x, -8) + + return slice(convert(y, bytes32), start=24, len=8) + + +@public +@constant +def from_little_endian_64(value: bytes[8]) -> uint256: + y: uint256 = 0 + x: uint256 = convert(value, uint256) + for i in range(8): + y = y + shift(bitwise_and(x, 255), 8 * (7-i)) + x = shift(x, -8) + + return y + + +@public +@constant +def get_deposit_root() -> bytes32: + root: bytes32 = 0x0000000000000000000000000000000000000000000000000000000000000000 + size: uint256 = self.deposit_count + for h in range(DEPOSIT_CONTRACT_TREE_DEPTH): + if bitwise_and(size, 1) == 1: + root = sha256(concat(self.branch[h], root)) + else: + root = sha256(concat(root, self.zerohashes[h])) + size /= 2 + return root + +@public +@constant +def get_deposit_count() -> bytes[8]: + return self.to_little_endian_64(self.deposit_count) + +@payable +@public +def deposit(pubkey: bytes[48], withdrawal_credentials: bytes[32], signature: bytes[96]): + deposit_amount: uint256 = msg.value / as_wei_value(1, "gwei") + assert deposit_amount >= MIN_DEPOSIT_AMOUNT + amount: bytes[8] = self.to_little_endian_64(deposit_amount) + + index: uint256 = self.deposit_count + + # add deposit to merkle tree + i: int128 = 0 + power_of_two: uint256 = 2 + for _ in range(DEPOSIT_CONTRACT_TREE_DEPTH): + if (index+1) % power_of_two != 0: + break + i += 1 + power_of_two *= 2 + + zero_bytes_32: bytes32 + pubkey_root: bytes32 = sha256(concat(pubkey, slice(zero_bytes_32, start=0, len=16))) + signature_root: bytes32 = sha256(concat( + sha256(slice(signature, start=0, len=64)), + sha256(concat(slice(signature, start=64, len=32), zero_bytes_32)) + )) + value: bytes32 = sha256(concat( + sha256(concat(pubkey_root, withdrawal_credentials)), + sha256(concat( + amount, + slice(zero_bytes_32, start=0, len=24), + signature_root, + )) + )) + for j in range(DEPOSIT_CONTRACT_TREE_DEPTH): + if j < i: + value = sha256(concat(self.branch[j], value)) + else: + break + self.branch[i] = value + + self.deposit_count += 1 + new_deposit_root: bytes32 = self.get_deposit_root() + log.Deposit( + pubkey, + withdrawal_credentials, + amount, + signature, + self.to_little_endian_64(index), + ) + + if deposit_amount >= FULL_DEPOSIT_AMOUNT: + self.full_deposit_count += 1 + if self.full_deposit_count == CHAIN_START_FULL_DEPOSIT_THRESHOLD: + timestamp_day_boundary: uint256 = ( + as_unitless_number(block.timestamp) - + as_unitless_number(block.timestamp) % SECONDS_PER_DAY + + 2 * SECONDS_PER_DAY + ) + log.Eth2Genesis(new_deposit_root, + self.to_little_endian_64(self.deposit_count), + self.to_little_endian_64(timestamp_day_boundary)) + self.chainStarted = True diff --git a/deposit_contract/requirements-testing.txt b/deposit_contract/requirements-testing.txt new file mode 100644 index 000000000..5900af8f0 --- /dev/null +++ b/deposit_contract/requirements-testing.txt @@ -0,0 +1,7 @@ +pytest>=3.6,<3.7 +tox==3.0.0, +eth-tester[py-evm]==0.1.0b29, +vyper==0.1.0b9, +web3==4.8.3, +pytest==3.6.1, +../../test_libs/pyspec diff --git a/deposit_contract/tests/__init__.py b/deposit_contract/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/deposit_contract/tests/contracts/__init__.py b/deposit_contract/tests/contracts/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/deposit_contract/tests/contracts/conftest.py b/deposit_contract/tests/contracts/conftest.py new file mode 100644 index 000000000..634ab26fa --- /dev/null +++ b/deposit_contract/tests/contracts/conftest.py @@ -0,0 +1,111 @@ +from random import ( + randint, +) +import re + +import pytest + +from deposit_contract.contracts.utils import ( + get_deposit_contract_code, + get_deposit_contract_json, +) +import eth_tester +from eth_tester import ( + EthereumTester, + PyEVMBackend, +) +from vyper import ( + compiler, +) +from web3 import Web3 +from web3.providers.eth_tester import ( + EthereumTesterProvider, +) + +# Constants +MIN_DEPOSIT_AMOUNT = 1000000000 # Gwei +FULL_DEPOSIT_AMOUNT = 32000000000 # Gwei +CHAIN_START_FULL_DEPOSIT_THRESHOLD = 65536 # 2**16 +DEPOSIT_CONTRACT_TREE_DEPTH = 32 +TWO_TO_POWER_OF_TREE_DEPTH = 2**DEPOSIT_CONTRACT_TREE_DEPTH + + +@pytest.fixture +def tester(): + return EthereumTester(PyEVMBackend()) + + +@pytest.fixture +def a0(tester): + return tester.get_accounts()[0] + + +@pytest.fixture +def w3(tester): + web3 = Web3(EthereumTesterProvider(tester)) + return web3 + + +@pytest.fixture +def registration_contract(w3, tester): + contract_bytecode = get_deposit_contract_json()['bytecode'] + contract_abi = get_deposit_contract_json()['abi'] + registration = w3.eth.contract( + abi=contract_abi, + bytecode=contract_bytecode) + tx_hash = registration.constructor().transact() + tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash) + registration_deployed = w3.eth.contract( + address=tx_receipt.contractAddress, + abi=contract_abi + ) + return registration_deployed + + +@pytest.fixture(scope="session") +def chain_start_full_deposit_thresholds(): + return [randint(1, 5), randint(6, 10), randint(11, 15)] + + +@pytest.fixture(params=[0, 1, 2]) +def modified_registration_contract( + request, + w3, + tester, + chain_start_full_deposit_thresholds): + # Set CHAIN_START_FULL_DEPOSIT_THRESHOLD to different threshold t + registration_code = get_deposit_contract_code() + t = str(chain_start_full_deposit_thresholds[request.param]) + modified_registration_code = re.sub( + r'CHAIN_START_FULL_DEPOSIT_THRESHOLD: constant\(uint256\) = [0-9]+', + 'CHAIN_START_FULL_DEPOSIT_THRESHOLD: constant(uint256) = ' + t, + registration_code, + ) + assert modified_registration_code != registration_code + contract_bytecode = compiler.compile_code(modified_registration_code)['bytecode'] + contract_abi = compiler.mk_full_signature(modified_registration_code) + registration = w3.eth.contract( + abi=contract_abi, + bytecode=contract_bytecode) + tx_hash = registration.constructor().transact() + tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash) + registration_deployed = w3.eth.contract( + address=tx_receipt.contractAddress, + abi=contract_abi + ) + setattr( + registration_deployed, + 'chain_start_full_deposit_threshold', + chain_start_full_deposit_thresholds[request.param] + ) + return registration_deployed + + +@pytest.fixture +def assert_tx_failed(tester): + def assert_tx_failed(function_to_test, exception=eth_tester.exceptions.TransactionFailed): + snapshot_id = tester.take_snapshot() + with pytest.raises(exception): + function_to_test() + tester.revert_to_snapshot(snapshot_id) + return assert_tx_failed diff --git a/deposit_contract/tests/contracts/test_compile.py b/deposit_contract/tests/contracts/test_compile.py new file mode 100644 index 000000000..72593fd5b --- /dev/null +++ b/deposit_contract/tests/contracts/test_compile.py @@ -0,0 +1,18 @@ +from deposit_contract.contracts.utils import ( + get_deposit_contract_code, + get_deposit_contract_json, +) +from vyper import ( + compiler, +) + + +def test_compile_deposit_contract(): + compiled_deposit_contract_json = get_deposit_contract_json() + + deposit_contract_code = get_deposit_contract_code() + abi = compiler.mk_full_signature(deposit_contract_code) + bytecode = compiler.compile_code(deposit_contract_code)['bytecode'] + + assert abi == compiled_deposit_contract_json["abi"] + assert bytecode == compiled_deposit_contract_json["bytecode"] diff --git a/deposit_contract/tests/contracts/test_deposit.py b/deposit_contract/tests/contracts/test_deposit.py new file mode 100644 index 000000000..600d74c85 --- /dev/null +++ b/deposit_contract/tests/contracts/test_deposit.py @@ -0,0 +1,221 @@ +from hashlib import ( + sha256, +) +from random import ( + randint, +) + +import pytest + +import eth_utils +from tests.contracts.conftest import ( + DEPOSIT_CONTRACT_TREE_DEPTH, + FULL_DEPOSIT_AMOUNT, + MIN_DEPOSIT_AMOUNT, +) +from eth2spec.utils.minimal_ssz import + SSZType, + hash_tree_root, +) + + +DepositData = SSZType({ + # BLS pubkey + 'pubkey': 'bytes48', + # Withdrawal credentials + 'withdrawal_credentials': 'bytes32', + # Amount in Gwei + 'amount': 'uint64', + # Container self-signature + 'signature': 'bytes96', +}) + + +def hash(data): + return sha256(data).digest() + + +def compute_merkle_root(leaf_nodes): + assert len(leaf_nodes) >= 1 + empty_node = b'\x00' * 32 + child_nodes = leaf_nodes[:] + for _ in range(DEPOSIT_CONTRACT_TREE_DEPTH): + parent_nodes = [] + if len(child_nodes) % 2 == 1: + child_nodes.append(empty_node) + for j in range(0, len(child_nodes), 2): + parent_nodes.append(hash(child_nodes[j] + child_nodes[j + 1])) + child_nodes = parent_nodes + empty_node = hash(empty_node + empty_node) + return child_nodes[0] + + +@pytest.fixture +def deposit_input(): + """ + pubkey: bytes[48] + withdrawal_credentials: bytes[32] + signature: bytes[96] + """ + return ( + b'\x11' * 48, + b'\x22' * 32, + b'\x33' * 96, + ) + + +@pytest.mark.parametrize( + 'value,success', + [ + (0, True), + (10, True), + (55555, True), + (2**64 - 1, True), + (2**64, False), + ] +) +def test_to_little_endian_64(registration_contract, value, success, assert_tx_failed): + call = registration_contract.functions.to_little_endian_64(value) + + if success: + little_endian_64 = call.call() + assert little_endian_64 == (value).to_bytes(8, 'little') + else: + assert_tx_failed( + lambda: call.call() + ) + + +def test_from_little_endian_64(registration_contract, assert_tx_failed): + values = [0, 2**64 - 1] + [randint(1, 2**64 - 2) for _ in range(10)] + for value in values: + call = registration_contract.functions.from_little_endian_64((value).to_bytes(8, 'little')) + assert call.call() == value + + +@pytest.mark.parametrize( + 'success,deposit_amount', + [ + (True, FULL_DEPOSIT_AMOUNT), + (True, MIN_DEPOSIT_AMOUNT), + (False, MIN_DEPOSIT_AMOUNT - 1), + (True, FULL_DEPOSIT_AMOUNT + 1) + ] +) +def test_deposit_amount(registration_contract, + w3, + success, + deposit_amount, + assert_tx_failed, + deposit_input): + call = registration_contract.functions.deposit(*deposit_input) + if success: + assert call.transact({"value": deposit_amount * eth_utils.denoms.gwei}) + else: + assert_tx_failed( + lambda: call.transact({"value": deposit_amount * eth_utils.denoms.gwei}) + ) + + +def test_deposit_log(registration_contract, a0, w3, deposit_input): + log_filter = registration_contract.events.Deposit.createFilter( + fromBlock='latest', + ) + + deposit_amount_list = [randint(MIN_DEPOSIT_AMOUNT, FULL_DEPOSIT_AMOUNT * 2) for _ in range(3)] + for i in range(3): + registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": deposit_amount_list[i] * eth_utils.denoms.gwei}) + + logs = log_filter.get_new_entries() + assert len(logs) == 1 + log = logs[0]['args'] + + assert log['pubkey'] == deposit_input[0] + assert log['withdrawal_credentials'] == deposit_input[1] + assert log['amount'] == deposit_amount_list[i].to_bytes(8, 'little') + assert log['signature'] == deposit_input[2] + assert log['merkle_tree_index'] == i.to_bytes(8, 'little') + + +def test_deposit_tree(registration_contract, w3, assert_tx_failed, deposit_input): + log_filter = registration_contract.events.Deposit.createFilter( + fromBlock='latest', + ) + + deposit_amount_list = [randint(MIN_DEPOSIT_AMOUNT, FULL_DEPOSIT_AMOUNT * 2) for _ in range(10)] + leaf_nodes = [] + for i in range(0, 10): + tx_hash = registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": deposit_amount_list[i] * eth_utils.denoms.gwei}) + receipt = w3.eth.getTransactionReceipt(tx_hash) + print("deposit transaction consumes %d gas" % receipt['gasUsed']) + + logs = log_filter.get_new_entries() + assert len(logs) == 1 + log = logs[0]['args'] + + assert log["merkle_tree_index"] == i.to_bytes(8, 'little') + + deposit_data = DepositData( + pubkey=deposit_input[0][:20], + withdrawal_credentials=deposit_input[1], + amount=deposit_amount_list[i], + signature=deposit_input[2], + ) + hash_tree_root_result = hash_tree_root(deposit_data) + leaf_nodes.append(hash_tree_root_result) + root = compute_merkle_root(leaf_nodes) + assert root == registration_contract.functions.get_deposit_root().call() + + +def test_chain_start(modified_registration_contract, w3, assert_tx_failed, deposit_input): + t = getattr(modified_registration_contract, 'chain_start_full_deposit_threshold') + # CHAIN_START_FULL_DEPOSIT_THRESHOLD is set to t + min_deposit_amount = MIN_DEPOSIT_AMOUNT * eth_utils.denoms.gwei # in wei + full_deposit_amount = FULL_DEPOSIT_AMOUNT * eth_utils.denoms.gwei + log_filter = modified_registration_contract.events.Eth2Genesis.createFilter( + fromBlock='latest', + ) + + index_not_full_deposit = randint(0, t - 1) + for i in range(t): + if i == index_not_full_deposit: + # Deposit with value below FULL_DEPOSIT_AMOUNT + modified_registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": min_deposit_amount}) + logs = log_filter.get_new_entries() + # Eth2Genesis event should not be triggered + assert len(logs) == 0 + else: + # Deposit with value FULL_DEPOSIT_AMOUNT + modified_registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": full_deposit_amount}) + logs = log_filter.get_new_entries() + # Eth2Genesis event should not be triggered + assert len(logs) == 0 + + # Make 1 more deposit with value FULL_DEPOSIT_AMOUNT to trigger Eth2Genesis event + modified_registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": full_deposit_amount}) + logs = log_filter.get_new_entries() + assert len(logs) == 1 + timestamp = int(w3.eth.getBlock(w3.eth.blockNumber)['timestamp']) + timestamp_day_boundary = timestamp + (86400 - timestamp % 86400) + 86400 + log = logs[0]['args'] + assert log['deposit_root'] == modified_registration_contract.functions.get_deposit_root().call() + assert int.from_bytes(log['time'], byteorder='little') == timestamp_day_boundary + assert modified_registration_contract.functions.chainStarted().call() is True + + # Make 1 deposit with value FULL_DEPOSIT_AMOUNT and + # check that Eth2Genesis event is not triggered + modified_registration_contract.functions.deposit( + *deposit_input, + ).transact({"value": full_deposit_amount}) + logs = log_filter.get_new_entries() + assert len(logs) == 0 diff --git a/deposit_contract/tests/core/conftest.py b/deposit_contract/tests/core/conftest.py new file mode 100644 index 000000000..e69de29bb diff --git a/deposit_contract/tests/core/test_import.py b/deposit_contract/tests/core/test_import.py new file mode 100644 index 000000000..d25e6ed67 --- /dev/null +++ b/deposit_contract/tests/core/test_import.py @@ -0,0 +1,4 @@ + + +def test_import(): + import deposit_contract # noqa: F401 diff --git a/deposit_contract/tool/compile_deposit_contract.py b/deposit_contract/tool/compile_deposit_contract.py new file mode 100644 index 000000000..58f974b8d --- /dev/null +++ b/deposit_contract/tool/compile_deposit_contract.py @@ -0,0 +1,33 @@ +import argparse +import json +import os + +from vyper import ( + compiler, +) + +DIR = os.path.dirname(__file__) + + +def generate_compiled_json(file_path: str): + deposit_contract_code = open(file_path).read() + abi = compiler.mk_full_signature(deposit_contract_code) + bytecode = compiler.compile_code(deposit_contract_code)['bytecode'] + contract_json = { + 'abi': abi, + 'bytecode': bytecode, + } + # write json + basename = os.path.basename(file_path) + dirname = os.path.dirname(file_path) + contract_name = basename.split('.')[0] + with open(dirname + "/{}.json".format(contract_name), 'w') as f_write: + json.dump(contract_json, f_write) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("path", type=str, help="the path of the contract") + args = parser.parse_args() + path = args.path + generate_compiled_json(path)