diff --git a/.circleci/config.yml b/.circleci/config.yml index 244d20c55..6e9a77c49 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1,7 +1,7 @@ version: 2.1 commands: restore_cached_venv: - description: "Restores a cached venv" + description: "Restore a cached venv" parameters: reqs_checksum: type: string @@ -16,7 +16,7 @@ commands: # fallback to using the latest cache if no exact match is found - << parameters.venv_name >>-venv- save_cached_venv: - description: "Saves a venv into a cache" + description: "Save a venv into a cache" parameters: reqs_checksum: type: string @@ -31,6 +31,32 @@ commands: - save_cache: key: << parameters.venv_name >>-venv-<< parameters.reqs_checksum >> paths: << parameters.venv_path >> + restore_pyspec_cached_venv: + description: "Restore the cache with pyspec keys" + steps: + - restore_cached_venv: + venv_name: v2-pyspec + reqs_checksum: cache-{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }} + save_pyspec_cached_venv: + description: Save a venv into a cache with pyspec keys" + steps: + - save_cached_venv: + venv_name: v2-pyspec + reqs_checksum: cache-{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }} + venv_path: ./test_libs/pyspec/venv + restore_deposit_contract_cached_venv: + description: "Restore the cache with deposit_contract keys" + steps: + - restore_cached_venv: + venv_name: v4-deposit-contract + reqs_checksum: cache-{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "deposit_contract/requirements-testing.txt" }} + save_deposit_contract_cached_venv: + description: Save a venv into a cache with deposit_contract keys" + steps: + - save_cached_venv: + venv_name: v4-deposit-contract + reqs_checksum: cache-{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "deposit_contract/requirements-testing.txt" }} + venv_path: ./deposit_contract/venv jobs: checkout_specs: docker: @@ -52,23 +78,18 @@ jobs: key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} paths: - ~/specs-repo - install_env: + install_pyspec_test: docker: - image: circleci/python:3.6 working_directory: ~/specs-repo steps: - restore_cache: key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} - - restore_cached_venv: - venv_name: v2-pyspec - reqs_checksum: '{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }}' + - restore_pyspec_cached_venv - run: name: Install pyspec requirements command: make install_test - - save_cached_venv: - venv_name: v2-pyspec - reqs_checksum: '{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }}' - venv_path: ./test_libs/pyspec/venv + - save_pyspec_cached_venv test: docker: - image: circleci/python:3.6 @@ -76,9 +97,7 @@ jobs: steps: - restore_cache: key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} - - restore_cached_venv: - venv_name: v2-pyspec - reqs_checksum: '{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }}' + - restore_pyspec_cached_venv - run: name: Run py-tests command: make citest @@ -91,23 +110,50 @@ jobs: steps: - restore_cache: key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} - - restore_cached_venv: - venv_name: v2-pyspec - reqs_checksum: '{{ checksum "test_libs/pyspec/requirements.txt" }}-{{ checksum "test_libs/pyspec/requirements-testing.txt" }}' + - restore_pyspec_cached_venv - run: name: Run linter command: make lint + install_deposit_contract_test: + docker: + - image: circleci/python:3.6 + working_directory: ~/specs-repo + steps: + - restore_cache: + key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} + - restore_deposit_contract_cached_venv + - run: + name: Install deposit contract requirements + command: make install_deposit_contract_test + - save_deposit_contract_cached_venv + deposit_contract: + docker: + - image: circleci/python:3.6 + working_directory: ~/specs-repo + steps: + - restore_cache: + key: v1-specs-repo-{{ .Branch }}-{{ .Revision }} + - restore_deposit_contract_cached_venv + - run: + name: Run deposit contract test + command: make test_deposit_contract workflows: version: 2.1 test_spec: jobs: - checkout_specs - - install_env: + - install_pyspec_test: requires: - checkout_specs - test: requires: - - install_env + - install_pyspec_test - lint: requires: - test + - install_deposit_contract_test: + requires: + - checkout_specs + - deposit_contract: + requires: + - install_deposit_contract_test diff --git a/Makefile b/Makefile index 5aeb8563f..f79b89dad 100644 --- a/Makefile +++ b/Makefile @@ -4,6 +4,7 @@ TEST_LIBS_DIR = ./test_libs PY_SPEC_DIR = $(TEST_LIBS_DIR)/pyspec YAML_TEST_DIR = ./eth2.0-spec-tests/tests GENERATOR_DIR = ./test_generators +DEPOSIT_CONTRACT_DIR = ./deposit_contract CONFIGS_DIR = ./configs # Collect a list of generator names @@ -21,7 +22,7 @@ PY_SPEC_PHASE_1_DEPS = $(SPEC_DIR)/core/1_*.md PY_SPEC_ALL_TARGETS = $(PY_SPEC_PHASE_0_TARGETS) $(PY_SPEC_PHASE_1_TARGETS) -.PHONY: clean all test citest gen_yaml_tests pyspec phase0 phase1 install_test +.PHONY: clean all test citest lint gen_yaml_tests pyspec phase0 phase1 install_test install_deposit_contract_test test_deposit_contract compile_deposit_contract all: $(PY_SPEC_ALL_TARGETS) $(YAML_TEST_DIR) $(YAML_TEST_TARGETS) @@ -30,6 +31,7 @@ clean: rm -rf $(GENERATOR_VENVS) rm -rf $(PY_SPEC_DIR)/venv $(PY_SPEC_DIR)/.pytest_cache rm -rf $(PY_SPEC_ALL_TARGETS) + rm -rf $(DEPOSIT_CONTRACT_DIR)/venv $(DEPOSIT_CONTRACT_DIR)/.pytest_cache # "make gen_yaml_tests" to run generators gen_yaml_tests: $(PY_SPEC_ALL_TARGETS) $(YAML_TEST_TARGETS) @@ -49,6 +51,17 @@ lint: $(PY_SPEC_ALL_TARGETS) cd $(PY_SPEC_DIR); . venv/bin/activate; \ flake8 --ignore=E252,W504,W503 --max-line-length=120 ./eth2spec; +install_deposit_contract_test: $(PY_SPEC_ALL_TARGETS) + cd $(DEPOSIT_CONTRACT_DIR); python3 -m venv venv; . venv/bin/activate; pip3 install -r requirements-testing.txt + +compile_deposit_contract: + cd $(DEPOSIT_CONTRACT_DIR); . venv/bin/activate; \ + python tool/compile_deposit_contract.py contracts/validator_registration.v.py; + +test_deposit_contract: + cd $(DEPOSIT_CONTRACT_DIR); . venv/bin/activate; \ + python -m pytest . + # "make pyspec" to create the pyspec for all phases. pyspec: $(PY_SPEC_ALL_TARGETS) diff --git a/deposit_contract/README.md b/deposit_contract/README.md new file mode 100644 index 000000000..16779e777 --- /dev/null +++ b/deposit_contract/README.md @@ -0,0 +1,24 @@ +# Deposit contract + +## How to set up the testing environment? + +Under the `eth2.0-specs` directory, execute: + +```sh +make install_deposit_contract_test +``` + +## How to compile the contract? + +```sh +make compile_deposit_contract +``` + +The ABI and bytecode will be updated at [`contracts/validator_registration.json`](./contracts/validator_registration.json). + + +## How to run tests? + +```sh +make test_deposit_contract +``` 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/validator_registration.json b/deposit_contract/contracts/validator_registration.json new file mode 100644 index 000000000..08d57f80a --- /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": "get_deposit_root", "outputs": [{"type": "bytes32", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 79221}, {"name": "get_deposit_count", "outputs": [{"type": "bytes", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 11026}, {"name": "deposit", "outputs": [], "inputs": [{"type": "bytes", "name": "pubkey"}, {"type": "bytes", "name": "withdrawal_credentials"}, {"type": "bytes", "name": "signature"}], "constant": false, "payable": true, "type": "function", "gas": 445994}, {"name": "chainStarted", "outputs": [{"type": "bool", "name": "out"}], "inputs": [], "constant": true, "payable": false, "type": "function", "gas": 603}], "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..1d475311a --- /dev/null +++ b/deposit_contract/contracts/validator_registration.v.py @@ -0,0 +1,140 @@ +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 +PUBKEY_LENGTH: constant(uint256) = 48 # bytes +WITHDRAWAL_CREDENTIALS_LENGTH: constant(uint256) = 32 # bytes +SIGNATURE_LENGTH: constant(uint256) = 96 # bytes +MAX_DEPOSIT_COUNT: constant(uint256) = 4294967295 # 2**DEPOSIT_CONTRACT_TREE_DEPTH - 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])) + + +@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 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[PUBKEY_LENGTH], + withdrawal_credentials: bytes[WITHDRAWAL_CREDENTIALS_LENGTH], + signature: bytes[SIGNATURE_LENGTH]): + # Prevent edge case in computing `self.branch` when `self.deposit_count == MAX_DEPOSIT_COUNT` + # NOTE: reaching this point with the constants as currently defined is impossible due to the + # uni-directional nature of transfers from eth1 to eth2 and the total ether supply (< 130M). + assert self.deposit_count < MAX_DEPOSIT_COUNT + + assert len(pubkey) == PUBKEY_LENGTH + assert len(withdrawal_credentials) == WITHDRAWAL_CREDENTIALS_LENGTH + assert len(signature) == SIGNATURE_LENGTH + + 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 + size: uint256 = index + 1 + for _ in range(DEPOSIT_CONTRACT_TREE_DEPTH): + if bitwise_and(size, 1) == 1: + break + i += 1 + size /= 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 + 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 + ) + new_deposit_root: bytes32 = self.get_deposit_root() + 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..b3a90a88a --- /dev/null +++ b/deposit_contract/requirements-testing.txt @@ -0,0 +1,5 @@ +eth-tester[py-evm]==0.1.0b39 +vyper==0.1.0b9 +web3==5.0.0b2 +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..69ece247d --- /dev/null +++ b/deposit_contract/tests/contracts/conftest.py @@ -0,0 +1,112 @@ +from random import ( + randint, +) +import re + +import pytest + +import eth_tester +from eth_tester import ( + EthereumTester, + PyEVMBackend, +) +from vyper import ( + compiler, +) +from web3 import Web3 +from web3.providers.eth_tester import ( + EthereumTesterProvider, +) +from .utils import ( + get_deposit_contract_code, + get_deposit_contract_json, +) + + +# 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..fc732a6db --- /dev/null +++ b/deposit_contract/tests/contracts/test_compile.py @@ -0,0 +1,19 @@ +from vyper import ( + compiler, +) + +from .utils import ( + get_deposit_contract_code, + get_deposit_contract_json, +) + + +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..8492d6347 --- /dev/null +++ b/deposit_contract/tests/contracts/test_deposit.py @@ -0,0 +1,236 @@ +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.phase0.spec import ( + DepositData, +) +from eth2spec.utils.hash_function import hash +from eth2spec.utils.ssz.ssz_impl import ( + hash_tree_root, +) + + +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() + ) + + +@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}) + ) + + +@pytest.mark.parametrize( + 'invalid_pubkey,invalid_withdrawal_credentials,invalid_signature,success', + [ + (False, False, False, True), + (True, False, False, False), + (False, True, False, False), + (False, False, True, False), + ] +) +def test_deposit_inputs(registration_contract, + w3, + assert_tx_failed, + deposit_input, + invalid_pubkey, + invalid_withdrawal_credentials, + invalid_signature, + success): + pubkey = deposit_input[0][2:] if invalid_pubkey else deposit_input[0] + if invalid_withdrawal_credentials: # this one is different to satisfy linter + withdrawal_credentials = deposit_input[1][2:] + else: + withdrawal_credentials = deposit_input[1] + signature = deposit_input[2][2:] if invalid_signature else deposit_input[2] + + call = registration_contract.functions.deposit( + pubkey, + withdrawal_credentials, + signature, + ) + if success: + assert call.transact({"value": FULL_DEPOSIT_AMOUNT * eth_utils.denoms.gwei}) + else: + assert_tx_failed( + lambda: call.transact({"value": FULL_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], + 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/contracts/utils.py b/deposit_contract/tests/contracts/utils.py new file mode 100644 index 000000000..de7c54489 --- /dev/null +++ b/deposit_contract/tests/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, './../../contracts/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, './../../contracts/validator_registration.json') + deposit_contract_json = open(file_path).read() + return json.loads(deposit_contract_json) 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)