diff --git a/.github/workflows/era-tester.yml b/.github/workflows/era-tester.yml
index 187b5c03a2..3e0bb3e941 100644
--- a/.github/workflows/era-tester.yml
+++ b/.github/workflows/era-tester.yml
@@ -98,6 +98,7 @@ jobs:
 
     - name: Run tester (fast)
       # Run era tester with no LLVM optimizations
+      continue-on-error: true
       if: ${{ github.ref != 'refs/heads/master' }}
       run: |
         cd era-compiler-tester
@@ -105,7 +106,12 @@ jobs:
 
     - name: Run tester (slow)
       # Run era tester across the LLVM optimization matrix
+      continue-on-error: true
       if: ${{ github.ref == 'refs/heads/master' }}
       run: |
         cd era-compiler-tester
         cargo run --release --bin compiler-tester -- --path=tests/vyper/ --mode="M*B* ${{ env.VYPER_VERSION }}"
+
+    - name: Mark as success
+      run: |
+        exit 0
diff --git a/README.md b/README.md
index af987ffd4f..bad929956d 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+**Vyper compiler security audit competition starts 14th September with $150k worth of bounties.** [See the competition on CodeHawks](https://www.codehawks.com/contests/cll5rujmw0001js08menkj7hc) and find [more details in this blog post](https://mirror.xyz/0xBA41A04A14aeaEec79e2D694B21ba5Ab610982f1/WTZ3l3MLhTz9P4avq6JqipN5d4HJNiUY-d8zT0pfmXg).
 
 <img src="https://raw.githubusercontent.com/vyperlang/vyper/master/logo/vyper-logo-transparent.svg?sanitize=true" alt="" width="110">
 
diff --git a/tests/parser/exceptions/test_structure_exception.py b/tests/parser/exceptions/test_structure_exception.py
index 08794b75f2..97ac2b139d 100644
--- a/tests/parser/exceptions/test_structure_exception.py
+++ b/tests/parser/exceptions/test_structure_exception.py
@@ -56,9 +56,26 @@ def double_nonreentrant():
     """,
     """
 @external
-@nonreentrant("B")
-@nonreentrant("C")
-def double_nonreentrant():
+@nonreentrant(" ")
+def invalid_nonreentrant_key():
+    pass
+    """,
+    """
+@external
+@nonreentrant("")
+def invalid_nonreentrant_key():
+    pass
+    """,
+    """
+@external
+@nonreentrant("123")
+def invalid_nonreentrant_key():
+    pass
+    """,
+    """
+@external
+@nonreentrant("!123abcd")
+def invalid_nonreentrant_key():
     pass
     """,
     """
diff --git a/tests/parser/features/decorators/test_nonreentrant.py b/tests/parser/features/decorators/test_nonreentrant.py
index ac73b35bec..9e74019250 100644
--- a/tests/parser/features/decorators/test_nonreentrant.py
+++ b/tests/parser/features/decorators/test_nonreentrant.py
@@ -142,7 +142,7 @@ def set_callback(c: address):
 
 @external
 @payable
-@nonreentrant('default')
+@nonreentrant("lock")
 def protected_function(val: String[100], do_callback: bool) -> uint256:
     self.special_value = val
     _amount: uint256 = msg.value
@@ -166,7 +166,7 @@ def unprotected_function(val: String[100], do_callback: bool):
 
 @external
 @payable
-@nonreentrant('default')
+@nonreentrant("lock")
 def __default__():
     pass
     """
diff --git a/tests/parser/test_call_graph_stability.py b/tests/parser/test_call_graph_stability.py
index b651092d16..a6193610e2 100644
--- a/tests/parser/test_call_graph_stability.py
+++ b/tests/parser/test_call_graph_stability.py
@@ -6,8 +6,8 @@
 from hypothesis import given, settings
 
 import vyper.ast as vy_ast
+from vyper.ast.identifiers import RESERVED_KEYWORDS
 from vyper.compiler.phases import CompilerData
-from vyper.semantics.namespace import RESERVED_KEYWORDS
 
 
 def _valid_identifier(attr):
diff --git a/tests/parser/test_selector_table.py b/tests/parser/test_selector_table.py
index 01a83698b7..3ac50707c2 100644
--- a/tests/parser/test_selector_table.py
+++ b/tests/parser/test_selector_table.py
@@ -10,6 +10,437 @@
 from vyper.compiler.settings import OptimizationLevel
 
 
+def test_dense_selector_table_empty_buckets(get_contract):
+    # some special combination of selectors which can result in
+    # some empty bucket being returned from _mk_buckets (that is,
+    # len(_mk_buckets(..., n_buckets)) != n_buckets
+    code = """
+@external
+def aX61QLPWF()->uint256:
+    return 1
+@external
+def aQHG0P2L1()->uint256:
+    return 2
+@external
+def a2G8ME94W()->uint256:
+    return 3
+@external
+def a0GNA21AY()->uint256:
+    return 4
+@external
+def a4U1XA4T5()->uint256:
+    return 5
+@external
+def aAYLMGOBZ()->uint256:
+    return 6
+@external
+def a0KXRLHKE()->uint256:
+    return 7
+@external
+def aDQS32HTR()->uint256:
+    return 8
+@external
+def aP4K6SA3S()->uint256:
+    return 9
+@external
+def aEB94ZP5S()->uint256:
+    return 10
+@external
+def aTOIMN0IM()->uint256:
+    return 11
+@external
+def aXV2N81OW()->uint256:
+    return 12
+@external
+def a66PP6Y5X()->uint256:
+    return 13
+@external
+def a5MWMTEWN()->uint256:
+    return 14
+@external
+def a5ZFST4Z8()->uint256:
+    return 15
+@external
+def aR13VXULX()->uint256:
+    return 16
+@external
+def aWITH917Y()->uint256:
+    return 17
+@external
+def a59NP6C5O()->uint256:
+    return 18
+@external
+def aJ02590EX()->uint256:
+    return 19
+@external
+def aUAXAAUQ8()->uint256:
+    return 20
+@external
+def aWR1XNC6J()->uint256:
+    return 21
+@external
+def aJABKZOKH()->uint256:
+    return 22
+@external
+def aO1TT0RJT()->uint256:
+    return 23
+@external
+def a41442IOK()->uint256:
+    return 24
+@external
+def aMVXV9FHQ()->uint256:
+    return 25
+@external
+def aNN0KJDZM()->uint256:
+    return 26
+@external
+def aOX965047()->uint256:
+    return 27
+@external
+def a575NX2J3()->uint256:
+    return 28
+@external
+def a16EN8O7W()->uint256:
+    return 29
+@external
+def aSZXLFF7O()->uint256:
+    return 30
+@external
+def aQKQCIPH9()->uint256:
+    return 31
+@external
+def aIP8021DL()->uint256:
+    return 32
+@external
+def aQAV0HSHX()->uint256:
+    return 33
+@external
+def aZVPAD745()->uint256:
+    return 34
+@external
+def aJYBSNST4()->uint256:
+    return 35
+@external
+def aQGWC4NYQ()->uint256:
+    return 36
+@external
+def aFMBB9CXJ()->uint256:
+    return 37
+@external
+def aYWM7ZUH1()->uint256:
+    return 38
+@external
+def aJAZONIX1()->uint256:
+    return 39
+@external
+def aQZ1HJK0H()->uint256:
+    return 40
+@external
+def aKIH9LOUB()->uint256:
+    return 41
+@external
+def aF4ZT80XL()->uint256:
+    return 42
+@external
+def aYQD8UKR5()->uint256:
+    return 43
+@external
+def aP6NCCAI4()->uint256:
+    return 44
+@external
+def aY92U2EAZ()->uint256:
+    return 45
+@external
+def aHMQ49D7P()->uint256:
+    return 46
+@external
+def aMC6YX8VF()->uint256:
+    return 47
+@external
+def a734X6YSI()->uint256:
+    return 48
+@external
+def aRXXPNSMU()->uint256:
+    return 49
+@external
+def aL5XKDTGT()->uint256:
+    return 50
+@external
+def a86V1Y18A()->uint256:
+    return 51
+@external
+def aAUM8PL5J()->uint256:
+    return 52
+@external
+def aBAEC1ERZ()->uint256:
+    return 53
+@external
+def a1U1VA3UE()->uint256:
+    return 54
+@external
+def aC9FGVAHC()->uint256:
+    return 55
+@external
+def aWN81WYJ3()->uint256:
+    return 56
+@external
+def a3KK1Y07J()->uint256:
+    return 57
+@external
+def aAZ6P6OSG()->uint256:
+    return 58
+@external
+def aWP5HCIB3()->uint256:
+    return 59
+@external
+def aVEK161C5()->uint256:
+    return 60
+@external
+def aY0Q3O519()->uint256:
+    return 61
+@external
+def aDHHHFIAE()->uint256:
+    return 62
+@external
+def aGSJBCZKQ()->uint256:
+    return 63
+@external
+def aZQQIUDHY()->uint256:
+    return 64
+@external
+def a12O9QDH5()->uint256:
+    return 65
+@external
+def aRQ1178XR()->uint256:
+    return 66
+@external
+def aDT25C832()->uint256:
+    return 67
+@external
+def aCSB01C4E()->uint256:
+    return 68
+@external
+def aYGBPKZSD()->uint256:
+    return 69
+@external
+def aP24N3EJ8()->uint256:
+    return 70
+@external
+def a531Y9X3C()->uint256:
+    return 71
+@external
+def a4727IKVS()->uint256:
+    return 72
+@external
+def a2EX1L2BS()->uint256:
+    return 73
+@external
+def a6145RN68()->uint256:
+    return 74
+@external
+def aDO1ZNX97()->uint256:
+    return 75
+@external
+def a3R28EU6M()->uint256:
+    return 76
+@external
+def a9BFC867L()->uint256:
+    return 77
+@external
+def aPL1MBGYC()->uint256:
+    return 78
+@external
+def aI6H11O48()->uint256:
+    return 79
+@external
+def aX0248DZY()->uint256:
+    return 80
+@external
+def aE4JBUJN4()->uint256:
+    return 81
+@external
+def aXBDB2ZBO()->uint256:
+    return 82
+@external
+def a7O7MYYHL()->uint256:
+    return 83
+@external
+def aERFF4PB6()->uint256:
+    return 84
+@external
+def aJCUBG6TJ()->uint256:
+    return 85
+@external
+def aQ5ELXM0F()->uint256:
+    return 86
+@external
+def aWDT9UQVV()->uint256:
+    return 87
+@external
+def a7UU40DJK()->uint256:
+    return 88
+@external
+def aH01IT5VS()->uint256:
+    return 89
+@external
+def aSKYTZ0FC()->uint256:
+    return 90
+@external
+def aNX5LYRAW()->uint256:
+    return 91
+@external
+def aUDKAOSGG()->uint256:
+    return 92
+@external
+def aZ86YGAAO()->uint256:
+    return 93
+@external
+def aIHWQGKLO()->uint256:
+    return 94
+@external
+def aKIKFLAR9()->uint256:
+    return 95
+@external
+def aCTPE0KRS()->uint256:
+    return 96
+@external
+def aAD75X00P()->uint256:
+    return 97
+@external
+def aDROUEF2F()->uint256:
+    return 98
+@external
+def a8CDIF6YN()->uint256:
+    return 99
+@external
+def aD2X7TM83()->uint256:
+    return 100
+@external
+def a3W5UUB4L()->uint256:
+    return 101
+@external
+def aG4MOBN4B()->uint256:
+    return 102
+@external
+def aPRS0MSG7()->uint256:
+    return 103
+@external
+def aKN3GHBUR()->uint256:
+    return 104
+@external
+def aGE435RHQ()->uint256:
+    return 105
+@external
+def a4E86BNFE()->uint256:
+    return 106
+@external
+def aYDG928YW()->uint256:
+    return 107
+@external
+def a2HFP5GQE()->uint256:
+    return 108
+@external
+def a5DPMVXKA()->uint256:
+    return 109
+@external
+def a3OFVC3DR()->uint256:
+    return 110
+@external
+def aK8F62DAN()->uint256:
+    return 111
+@external
+def aJS9EY3U6()->uint256:
+    return 112
+@external
+def aWW789JQH()->uint256:
+    return 113
+@external
+def a8AJJN3YR()->uint256:
+    return 114
+@external
+def a4D0MUIDU()->uint256:
+    return 115
+@external
+def a35W41JQR()->uint256:
+    return 116
+@external
+def a07DQOI1E()->uint256:
+    return 117
+@external
+def aFT43YNCT()->uint256:
+    return 118
+@external
+def a0E75I8X3()->uint256:
+    return 119
+@external
+def aT6NXIRO4()->uint256:
+    return 120
+@external
+def aXB2UBAKQ()->uint256:
+    return 121
+@external
+def aHWH55NW6()->uint256:
+    return 122
+@external
+def a7TCFE6C2()->uint256:
+    return 123
+@external
+def a8XYAM81I()->uint256:
+    return 124
+@external
+def aHQTQ4YBY()->uint256:
+    return 125
+@external
+def aGCZEHG6Y()->uint256:
+    return 126
+@external
+def a6LJTKIW0()->uint256:
+    return 127
+@external
+def aBDIXTD9S()->uint256:
+    return 128
+@external
+def aCB83G21P()->uint256:
+    return 129
+@external
+def aZC525N4K()->uint256:
+    return 130
+@external
+def a40LC94U6()->uint256:
+    return 131
+@external
+def a8X9TI93D()->uint256:
+    return 132
+@external
+def aGUG9CD8Y()->uint256:
+    return 133
+@external
+def a0LAERVAY()->uint256:
+    return 134
+@external
+def aXQ0UEX19()->uint256:
+    return 135
+@external
+def aKK9C7NE7()->uint256:
+    return 136
+@external
+def aS2APW8UE()->uint256:
+    return 137
+@external
+def a65NT07MM()->uint256:
+    return 138
+@external
+def aGRMT6ZW5()->uint256:
+    return 139
+@external
+def aILR4U1Z()->uint256:
+    return 140
+    """
+    c = get_contract(code)
+
+    assert c.aX61QLPWF() == 1  # will revert if the header section is misaligned
+
+
 @given(
     n_methods=st.integers(min_value=1, max_value=100),
     seed=st.integers(min_value=0, max_value=2**64 - 1),
diff --git a/tests/parser/test_selector_table_stability.py b/tests/parser/test_selector_table_stability.py
new file mode 100644
index 0000000000..abc2c17b8f
--- /dev/null
+++ b/tests/parser/test_selector_table_stability.py
@@ -0,0 +1,53 @@
+from vyper.codegen.jumptable_utils import generate_sparse_jumptable_buckets
+from vyper.compiler import compile_code
+from vyper.compiler.settings import OptimizationLevel, Settings
+
+
+def test_dense_jumptable_stability():
+    function_names = [f"foo{i}" for i in range(30)]
+
+    code = "\n".join(f"@external\ndef {name}():\n  pass" for name in function_names)
+
+    output = compile_code(code, ["asm"], settings=Settings(optimize=OptimizationLevel.CODESIZE))
+
+    # test that the selector table data is stable across different runs
+    # (tox should provide different PYTHONHASHSEEDs).
+    expected_asm = """{ DATA _sym_BUCKET_HEADERS b'\\x0bB' _sym_bucket_0 b'\\n' b'+\\x8d' _sym_bucket_1 b'\\x0c' b'\\x00\\x85' _sym_bucket_2 b'\\x08' } { DATA _sym_bucket_1 b'\\xd8\\xee\\xa1\\xe8' _sym_external_foo6___3639517672 b'\\x05' b'\\xd2\\x9e\\xe0\\xf9' _sym_external_foo0___3533627641 b'\\x05' b'\\x05\\xf1\\xe0_' _sym_external_foo2___99737695 b'\\x05' b'\\x91\\t\\xb4{' _sym_external_foo23___2433332347 b'\\x05' b'np3\\x7f' _sym_external_foo11___1852846975 b'\\x05' b'&\\xf5\\x96\\xf9' _sym_external_foo13___653629177 b'\\x05' b'\\x04ga\\xeb' _sym_external_foo14___73884139 b'\\x05' b'\\x89\\x06\\xad\\xc6' _sym_external_foo17___2298916294 b'\\x05' b'\\xe4%\\xac\\xd1' _sym_external_foo4___3827674321 b'\\x05' b'yj\\x01\\xac' _sym_external_foo7___2036990380 b'\\x05' b'\\xf1\\xe6K\\xe5' _sym_external_foo29___4058401765 b'\\x05' b'\\xd2\\x89X\\xb8' _sym_external_foo3___3532216504 b'\\x05' } { DATA _sym_bucket_2 b'\\x06p\\xffj' _sym_external_foo25___108068714 b'\\x05' b'\\x964\\x99I' _sym_external_foo24___2520029513 b'\\x05' b's\\x81\\xe7\\xc1' _sym_external_foo10___1937893313 b'\\x05' b'\\x85\\xad\\xc11' _sym_external_foo28___2242756913 b'\\x05' b'\\xfa"\\xb1\\xed' _sym_external_foo5___4196577773 b'\\x05' b'A\\xe7[\\x05' _sym_external_foo22___1105681157 b'\\x05' b'\\xd3\\x89U\\xe8' _sym_external_foo1___3548993000 b'\\x05' b'hL\\xf8\\xf3' _sym_external_foo20___1749874931 b'\\x05' } { DATA _sym_bucket_0 b'\\xee\\xd9\\x1d\\xe3' _sym_external_foo9___4007206371 b'\\x05' b'a\\xbc\\x1ch' _sym_external_foo16___1639717992 b'\\x05' b'\\xd3*\\xa7\\x0c' _sym_external_foo21___3542787852 b'\\x05' b'\\x18iG\\xd9' _sym_external_foo19___409552857 b'\\x05' b'\\n\\xf1\\xf9\\x7f' _sym_external_foo18___183630207 b'\\x05' b')\\xda\\xd7`' _sym_external_foo27___702207840 b'\\x05' b'2\\xf6\\xaa\\xda' _sym_external_foo12___855026394 b'\\x05' b'\\xbe\\xb5\\x05\\xf5' _sym_external_foo15___3199534581 b'\\x05' b'\\xfc\\xa7_\\xe6' _sym_external_foo8___4238827494 b'\\x05' b'\\x1b\\x12C8' _sym_external_foo26___454181688 b'\\x05' } }"""  # noqa: E501
+    assert expected_asm in output["asm"]
+
+
+def test_sparse_jumptable_stability():
+    function_names = [f"foo{i}()" for i in range(30)]
+
+    # sparse jumptable is not as complicated in assembly.
+    # here just test the data structure is stable
+
+    n_buckets, buckets = generate_sparse_jumptable_buckets(function_names)
+    assert n_buckets == 33
+
+    # the buckets sorted by id are what go into the IR, check equality against
+    # expected:
+    assert sorted(buckets.items()) == [
+        (0, [4238827494, 1639717992]),
+        (1, [1852846975]),
+        (2, [1749874931]),
+        (3, [4007206371]),
+        (4, [2298916294]),
+        (7, [2036990380]),
+        (10, [3639517672, 73884139]),
+        (12, [3199534581]),
+        (13, [99737695]),
+        (14, [3548993000, 4196577773]),
+        (15, [454181688, 702207840]),
+        (16, [3533627641]),
+        (17, [108068714]),
+        (20, [1105681157]),
+        (21, [409552857, 3542787852]),
+        (22, [4058401765]),
+        (23, [2520029513, 2242756913]),
+        (24, [855026394, 183630207]),
+        (25, [3532216504, 653629177]),
+        (26, [1937893313]),
+        (28, [2433332347]),
+        (31, [3827674321]),
+    ]
diff --git a/tests/parser/types/test_identifier_naming.py b/tests/parser/types/test_identifier_naming.py
index f4f602f471..5cfc7e8ed7 100755
--- a/tests/parser/types/test_identifier_naming.py
+++ b/tests/parser/types/test_identifier_naming.py
@@ -1,10 +1,10 @@
 import pytest
 
 from vyper.ast.folding import BUILTIN_CONSTANTS
+from vyper.ast.identifiers import RESERVED_KEYWORDS
 from vyper.builtins.functions import BUILTIN_FUNCTIONS
 from vyper.codegen.expr import ENVIRONMENT_VARIABLES
 from vyper.exceptions import NamespaceCollision, StructureException, SyntaxException
-from vyper.semantics.namespace import RESERVED_KEYWORDS
 from vyper.semantics.types.primitives import AddressT
 
 BUILTIN_CONSTANTS = set(BUILTIN_CONSTANTS.keys())
diff --git a/vyper/ast/identifiers.py b/vyper/ast/identifiers.py
new file mode 100644
index 0000000000..985b04e5cd
--- /dev/null
+++ b/vyper/ast/identifiers.py
@@ -0,0 +1,111 @@
+import re
+
+from vyper.exceptions import StructureException
+
+
+def validate_identifier(attr, ast_node=None):
+    if not re.match("^[_a-zA-Z][a-zA-Z0-9_]*$", attr):
+        raise StructureException(f"'{attr}' contains invalid character(s)", ast_node)
+    if attr.lower() in RESERVED_KEYWORDS:
+        raise StructureException(f"'{attr}' is a reserved keyword", ast_node)
+
+
+# https://docs.python.org/3/reference/lexical_analysis.html#keywords
+# note we don't technically need to block all python reserved keywords,
+# but do it for hygiene
+_PYTHON_RESERVED_KEYWORDS = {
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield",
+}
+_PYTHON_RESERVED_KEYWORDS = {s.lower() for s in _PYTHON_RESERVED_KEYWORDS}
+
+# Cannot be used for variable or member naming
+RESERVED_KEYWORDS = _PYTHON_RESERVED_KEYWORDS | {
+    # decorators
+    "public",
+    "external",
+    "nonpayable",
+    "constant",
+    "immutable",
+    "transient",
+    "internal",
+    "payable",
+    "nonreentrant",
+    # "class" keywords
+    "interface",
+    "struct",
+    "event",
+    "enum",
+    # EVM operations
+    "unreachable",
+    # special functions (no name mangling)
+    "init",
+    "_init_",
+    "___init___",
+    "____init____",
+    "default",
+    "_default_",
+    "___default___",
+    "____default____",
+    # more control flow and special operations
+    "range",
+    # more special operations
+    "indexed",
+    # denominations
+    "ether",
+    "wei",
+    "finney",
+    "szabo",
+    "shannon",
+    "lovelace",
+    "ada",
+    "babbage",
+    "gwei",
+    "kwei",
+    "mwei",
+    "twei",
+    "pwei",
+    # sentinal constant values
+    # TODO remove when these are removed from the language
+    "zero_address",
+    "empty_bytes32",
+    "max_int128",
+    "min_int128",
+    "max_decimal",
+    "min_decimal",
+    "max_uint256",
+    "zero_wei",
+}
diff --git a/vyper/codegen/jumptable_utils.py b/vyper/codegen/jumptable_utils.py
index 6987ce90bd..6404b75532 100644
--- a/vyper/codegen/jumptable_utils.py
+++ b/vyper/codegen/jumptable_utils.py
@@ -43,7 +43,11 @@ def _image_of(xs, magic):
     return [((x * magic) >> bits_shift) % len(xs) for x in xs]
 
 
-class _Failure(Exception):
+class _FindMagicFailure(Exception):
+    pass
+
+
+class _HasEmptyBuckets(Exception):
     pass
 
 
@@ -53,7 +57,7 @@ def find_magic_for(xs):
         if len(test) == len(set(test)):
             return m
 
-    raise _Failure(f"Could not find hash for {xs}")
+    raise _FindMagicFailure(f"Could not find hash for {xs}")
 
 
 def _mk_buckets(method_ids, n_buckets):
@@ -72,6 +76,11 @@ def _mk_buckets(method_ids, n_buckets):
 def _dense_jumptable_info(method_ids, n_buckets):
     buckets = _mk_buckets(method_ids, n_buckets)
 
+    # if there are somehow empty buckets, bail out as that can mess up
+    # the bucket header layout
+    if len(buckets) != n_buckets:
+        raise _HasEmptyBuckets()
+
     ret = {}
     for bucket_id, method_ids in buckets.items():
         magic = find_magic_for(method_ids)
@@ -98,8 +107,16 @@ def generate_dense_jumptable_info(signatures):
     while n_buckets > 0:
         try:
             # print(f"trying {n_buckets} (bucket size {n // n_buckets})")
-            ret = _dense_jumptable_info(method_ids, n_buckets)
-        except _Failure:
+            solution = _dense_jumptable_info(method_ids, n_buckets)
+            assert len(solution) == n_buckets
+            ret = n_buckets, solution
+
+        except _HasEmptyBuckets:
+            # found a solution which has empty buckets; skip it since
+            # it will break the bucket layout.
+            pass
+
+        except _FindMagicFailure:
             if ret is not None:
                 break
 
diff --git a/vyper/codegen/module.py b/vyper/codegen/module.py
index 8caea9ee9b..6445a5e1e0 100644
--- a/vyper/codegen/module.py
+++ b/vyper/codegen/module.py
@@ -124,8 +124,12 @@ def _selector_section_dense(external_functions, global_ctx):
         ir_node = ["label", label, ["var_list"], entry_point.ir_node]
         function_irs.append(IRnode.from_list(ir_node))
 
-    jumptable_info = jumptable_utils.generate_dense_jumptable_info(entry_points.keys())
-    n_buckets = len(jumptable_info)
+    n_buckets, jumptable_info = jumptable_utils.generate_dense_jumptable_info(entry_points.keys())
+    # note: we are guaranteed by jumptable_utils that there are no buckets
+    # which are empty. sanity check that the bucket ids are well-behaved:
+    assert n_buckets == len(jumptable_info)
+    for i, (bucket_id, _) in enumerate(sorted(jumptable_info.items())):
+        assert i == bucket_id
 
     #  bucket magic <2 bytes> | bucket location <2 bytes> | bucket size <1 byte>
     # TODO: can make it smaller if the largest bucket magic <= 255
diff --git a/vyper/exceptions.py b/vyper/exceptions.py
index aa23614e85..defca7cc53 100644
--- a/vyper/exceptions.py
+++ b/vyper/exceptions.py
@@ -54,7 +54,9 @@ def __init__(self, message="Error Message not found.", *items):
             # support older exceptions that don't annotate - remove this in the future!
             self.lineno, self.col_offset = items[0][:2]
         else:
-            self.annotations = items
+            # strip out None sources so that None can be passed as a valid
+            # annotation (in case it is only available optionally)
+            self.annotations = [k for k in items if k is not None]
 
     def with_annotation(self, *annotations):
         """
diff --git a/vyper/semantics/namespace.py b/vyper/semantics/namespace.py
index b88bc3d817..613ac0c03b 100644
--- a/vyper/semantics/namespace.py
+++ b/vyper/semantics/namespace.py
@@ -1,12 +1,7 @@
 import contextlib
-import re
-
-from vyper.exceptions import (
-    CompilerPanic,
-    NamespaceCollision,
-    StructureException,
-    UndeclaredDefinition,
-)
+
+from vyper.ast.identifiers import validate_identifier
+from vyper.exceptions import CompilerPanic, NamespaceCollision, UndeclaredDefinition
 from vyper.semantics.analysis.levenshtein_utils import get_levenshtein_error_suggestions
 
 
@@ -121,111 +116,3 @@ def override_global_namespace(ns):
     finally:
         # unclobber
         _namespace = tmp
-
-
-def validate_identifier(attr):
-    if not re.match("^[_a-zA-Z][a-zA-Z0-9_]*$", attr):
-        raise StructureException(f"'{attr}' contains invalid character(s)")
-    if attr.lower() in RESERVED_KEYWORDS:
-        raise StructureException(f"'{attr}' is a reserved keyword")
-
-
-# https://docs.python.org/3/reference/lexical_analysis.html#keywords
-# note we don't technically need to block all python reserved keywords,
-# but do it for hygiene
-_PYTHON_RESERVED_KEYWORDS = {
-    "False",
-    "None",
-    "True",
-    "and",
-    "as",
-    "assert",
-    "async",
-    "await",
-    "break",
-    "class",
-    "continue",
-    "def",
-    "del",
-    "elif",
-    "else",
-    "except",
-    "finally",
-    "for",
-    "from",
-    "global",
-    "if",
-    "import",
-    "in",
-    "is",
-    "lambda",
-    "nonlocal",
-    "not",
-    "or",
-    "pass",
-    "raise",
-    "return",
-    "try",
-    "while",
-    "with",
-    "yield",
-}
-_PYTHON_RESERVED_KEYWORDS = {s.lower() for s in _PYTHON_RESERVED_KEYWORDS}
-
-# Cannot be used for variable or member naming
-RESERVED_KEYWORDS = _PYTHON_RESERVED_KEYWORDS | {
-    # decorators
-    "public",
-    "external",
-    "nonpayable",
-    "constant",
-    "immutable",
-    "transient",
-    "internal",
-    "payable",
-    "nonreentrant",
-    # "class" keywords
-    "interface",
-    "struct",
-    "event",
-    "enum",
-    # EVM operations
-    "unreachable",
-    # special functions (no name mangling)
-    "init",
-    "_init_",
-    "___init___",
-    "____init____",
-    "default",
-    "_default_",
-    "___default___",
-    "____default____",
-    # more control flow and special operations
-    "range",
-    # more special operations
-    "indexed",
-    # denominations
-    "ether",
-    "wei",
-    "finney",
-    "szabo",
-    "shannon",
-    "lovelace",
-    "ada",
-    "babbage",
-    "gwei",
-    "kwei",
-    "mwei",
-    "twei",
-    "pwei",
-    # sentinal constant values
-    # TODO remove when these are removed from the language
-    "zero_address",
-    "empty_bytes32",
-    "max_int128",
-    "min_int128",
-    "max_decimal",
-    "min_decimal",
-    "max_uint256",
-    "zero_wei",
-}
diff --git a/vyper/semantics/types/base.py b/vyper/semantics/types/base.py
index af955f6071..c5af5c2a39 100644
--- a/vyper/semantics/types/base.py
+++ b/vyper/semantics/types/base.py
@@ -3,6 +3,7 @@
 
 from vyper import ast as vy_ast
 from vyper.abi_types import ABIType
+from vyper.ast.identifiers import validate_identifier
 from vyper.exceptions import (
     CompilerPanic,
     InvalidLiteral,
@@ -12,7 +13,6 @@
     UnknownAttribute,
 )
 from vyper.semantics.analysis.levenshtein_utils import get_levenshtein_error_suggestions
-from vyper.semantics.namespace import validate_identifier
 
 
 # Some fake type with an overridden `compare_type` which accepts any RHS
diff --git a/vyper/semantics/types/function.py b/vyper/semantics/types/function.py
index 506dae135c..77b9efb13d 100644
--- a/vyper/semantics/types/function.py
+++ b/vyper/semantics/types/function.py
@@ -5,6 +5,7 @@
 from typing import Any, Dict, List, Optional, Tuple
 
 from vyper import ast as vy_ast
+from vyper.ast.identifiers import validate_identifier
 from vyper.ast.validation import validate_call_args
 from vyper.exceptions import (
     ArgumentException,
@@ -220,7 +221,10 @@ def from_FunctionDef(
                         msg = "Nonreentrant decorator disallowed on `__init__`"
                         raise FunctionDeclarationException(msg, decorator)
 
-                    kwargs["nonreentrant"] = decorator.args[0].value
+                    nonreentrant_key = decorator.args[0].value
+                    validate_identifier(nonreentrant_key, decorator.args[0])
+
+                    kwargs["nonreentrant"] = nonreentrant_key
 
                 elif isinstance(decorator, vy_ast.Name):
                     if FunctionVisibility.is_valid_value(decorator.id):