diff --git a/vyper/builtins/_signatures.py b/vyper/builtins/_signatures.py
index 2802421129..a5949dfd85 100644
--- a/vyper/builtins/_signatures.py
+++ b/vyper/builtins/_signatures.py
@@ -1,5 +1,5 @@
 import functools
-from typing import Dict
+from typing import Any, Optional
 
 from vyper.ast import nodes as vy_ast
 from vyper.ast.validation import validate_call_args
@@ -74,12 +74,14 @@ def decorator_fn(self, node, context):
     return decorator_fn
 
 
-class BuiltinFunction(VyperType):
+class BuiltinFunctionT(VyperType):
     _has_varargs = False
-    _kwargs: Dict[str, KwargSettings] = {}
+    _inputs: list[tuple[str, Any]] = []
+    _kwargs: dict[str, KwargSettings] = {}
+    _return_type: Optional[VyperType] = None
 
     # helper function to deal with TYPE_DEFINITIONs
-    def _validate_single(self, arg, expected_type):
+    def _validate_single(self, arg: vy_ast.VyperNode, expected_type: VyperType) -> None:
         # TODO using "TYPE_DEFINITION" is a kludge in derived classes,
         # refactor me.
         if expected_type == "TYPE_DEFINITION":
@@ -89,15 +91,15 @@ def _validate_single(self, arg, expected_type):
         else:
             validate_expected_type(arg, expected_type)
 
-    def _validate_arg_types(self, node):
+    def _validate_arg_types(self, node: vy_ast.Call) -> None:
         num_args = len(self._inputs)  # the number of args the signature indicates
 
-        expect_num_args = num_args
+        expect_num_args: Any = num_args
         if self._has_varargs:
             # note special meaning for -1 in validate_call_args API
             expect_num_args = (num_args, -1)
 
-        validate_call_args(node, expect_num_args, self._kwargs)
+        validate_call_args(node, expect_num_args, list(self._kwargs.keys()))
 
         for arg, (_, expected) in zip(node.args, self._inputs):
             self._validate_single(arg, expected)
@@ -118,13 +120,12 @@ def _validate_arg_types(self, node):
             # ensures the type can be inferred exactly.
             get_exact_type_from_node(arg)
 
-    def fetch_call_return(self, node):
+    def fetch_call_return(self, node: vy_ast.Call) -> Optional[VyperType]:
         self._validate_arg_types(node)
 
-        if self._return_type:
-            return self._return_type
+        return self._return_type
 
-    def infer_arg_types(self, node):
+    def infer_arg_types(self, node: vy_ast.Call) -> list[VyperType]:
         self._validate_arg_types(node)
         ret = [expected for (_, expected) in self._inputs]
 
@@ -136,7 +137,7 @@ def infer_arg_types(self, node):
         ret.extend(get_exact_type_from_node(arg) for arg in varargs)
         return ret
 
-    def infer_kwarg_types(self, node):
+    def infer_kwarg_types(self, node: vy_ast.Call) -> dict[str, VyperType]:
         return {i.arg: self._kwargs[i.arg].typ for i in node.keywords}
 
     def __repr__(self):
diff --git a/vyper/builtins/functions.py b/vyper/builtins/functions.py
index 001939638b..b2d817ec5c 100644
--- a/vyper/builtins/functions.py
+++ b/vyper/builtins/functions.py
@@ -98,14 +98,14 @@
 )
 
 from ._convert import convert
-from ._signatures import BuiltinFunction, process_inputs
+from ._signatures import BuiltinFunctionT, process_inputs
 
 SHA256_ADDRESS = 2
 SHA256_BASE_GAS = 60
 SHA256_PER_WORD_GAS = 12
 
 
-class FoldedFunction(BuiltinFunction):
+class FoldedFunctionT(BuiltinFunctionT):
     # Base class for nodes which should always be folded
 
     # Since foldable builtin functions are not folded before semantics validation,
@@ -113,7 +113,7 @@ class FoldedFunction(BuiltinFunction):
     _kwargable = True
 
 
-class TypenameFoldedFunction(FoldedFunction):
+class TypenameFoldedFunctionT(FoldedFunctionT):
     # Base class for builtin functions that:
     # (1) take a typename as the only argument; and
     # (2) should always be folded.
@@ -132,7 +132,7 @@ def infer_arg_types(self, node):
         return [input_typedef]
 
 
-class Floor(BuiltinFunction):
+class Floor(BuiltinFunctionT):
     _id = "floor"
     _inputs = [("value", DecimalT())]
     # TODO: maybe use int136?
@@ -162,7 +162,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(ret)
 
 
-class Ceil(BuiltinFunction):
+class Ceil(BuiltinFunctionT):
     _id = "ceil"
     _inputs = [("value", DecimalT())]
     # TODO: maybe use int136?
@@ -192,7 +192,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(ret)
 
 
-class Convert(BuiltinFunction):
+class Convert(BuiltinFunctionT):
     _id = "convert"
 
     def fetch_call_return(self, node):
@@ -285,14 +285,13 @@ def _build_adhoc_slice_node(sub: IRnode, start: IRnode, length: IRnode, context:
 
 
 # note: this and a lot of other builtins could be refactored to accept any uint type
-class Slice(BuiltinFunction):
+class Slice(BuiltinFunctionT):
     _id = "slice"
     _inputs = [
         ("b", (BYTES32_T, BytesT.any(), StringT.any())),
         ("start", UINT256_T),
         ("length", UINT256_T),
     ]
-    _return_type = None
 
     def fetch_call_return(self, node):
         arg_type, _, _ = self.infer_arg_types(node)
@@ -457,7 +456,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(b2.resolve(b3.resolve(ret)))
 
 
-class Len(BuiltinFunction):
+class Len(BuiltinFunctionT):
     _id = "len"
     _inputs = [("b", (StringT.any(), BytesT.any(), DArrayT.any()))]
     _return_type = UINT256_T
@@ -488,7 +487,7 @@ def build_IR(self, node, context):
         return get_bytearray_length(arg)
 
 
-class Concat(BuiltinFunction):
+class Concat(BuiltinFunctionT):
     _id = "concat"
 
     def fetch_call_return(self, node):
@@ -593,7 +592,7 @@ def build_IR(self, expr, context):
         )
 
 
-class Keccak256(BuiltinFunction):
+class Keccak256(BuiltinFunctionT):
     _id = "keccak256"
     # TODO allow any BytesM_T
     _inputs = [("value", (BytesT.any(), BYTES32_T, StringT.any()))]
@@ -641,7 +640,7 @@ def _make_sha256_call(inp_start, inp_len, out_start, out_len):
     ]
 
 
-class Sha256(BuiltinFunction):
+class Sha256(BuiltinFunctionT):
     _id = "sha256"
     _inputs = [("value", (BYTES32_T, BytesT.any(), StringT.any()))]
     _return_type = BYTES32_T
@@ -713,7 +712,7 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class MethodID(FoldedFunction):
+class MethodID(FoldedFunctionT):
     _id = "method_id"
 
     def evaluate(self, node):
@@ -753,7 +752,7 @@ def infer_kwarg_types(self, node):
         return BytesT(4)
 
 
-class ECRecover(BuiltinFunction):
+class ECRecover(BuiltinFunctionT):
     _id = "ecrecover"
     _inputs = [
         ("hash", BYTES32_T),
@@ -788,7 +787,7 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class _ECArith(BuiltinFunction):
+class _ECArith(BuiltinFunctionT):
     @process_inputs
     def build_IR(self, expr, _args, kwargs, context):
         args_tuple = ir_tuple_from_args(_args)
@@ -847,14 +846,13 @@ def _storage_element_getter(index):
     return IRnode.from_list(["sload", ["add", "_sub", ["add", 1, index]]], typ=INT128_T)
 
 
-class Extract32(BuiltinFunction):
+class Extract32(BuiltinFunctionT):
     _id = "extract32"
     _inputs = [("b", BytesT.any()), ("start", IntegerT.unsigneds())]
     # "TYPE_DEFINITION" is a placeholder value for a type definition string, and
     # will be replaced by a `TYPE_T` object in `infer_kwarg_types`
     # (note that it is ignored in _validate_arg_types)
     _kwargs = {"output_type": KwargSettings("TYPE_DEFINITION", BYTES32_T)}
-    _return_type = None
 
     def fetch_call_return(self, node):
         self._validate_arg_types(node)
@@ -959,7 +957,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(clamp_basetype(o), typ=ret_type)
 
 
-class AsWeiValue(BuiltinFunction):
+class AsWeiValue(BuiltinFunctionT):
     _id = "as_wei_value"
     _inputs = [("value", (IntegerT.any(), DecimalT())), ("unit", StringT.any())]
     _return_type = UINT256_T
@@ -1058,7 +1056,7 @@ def build_IR(self, expr, args, kwargs, context):
 empty_value = IRnode.from_list(0, typ=BYTES32_T)
 
 
-class RawCall(BuiltinFunction):
+class RawCall(BuiltinFunctionT):
     _id = "raw_call"
     _inputs = [("to", AddressT()), ("data", BytesT.any())]
     _kwargs = {
@@ -1069,7 +1067,6 @@ class RawCall(BuiltinFunction):
         "is_static_call": KwargSettings(BoolT(), False, require_literal=True),
         "revert_on_failure": KwargSettings(BoolT(), True, require_literal=True),
     }
-    _return_type = None
 
     def fetch_call_return(self, node):
         self._validate_arg_types(node)
@@ -1215,12 +1212,11 @@ def build_IR(self, expr, args, kwargs, context):
         raise CompilerPanic("unreachable!")
 
 
-class Send(BuiltinFunction):
+class Send(BuiltinFunctionT):
     _id = "send"
     _inputs = [("to", AddressT()), ("value", UINT256_T)]
     # default gas stipend is 0
     _kwargs = {"gas": KwargSettings(UINT256_T, 0)}
-    _return_type = None
 
     @process_inputs
     def build_IR(self, expr, args, kwargs, context):
@@ -1232,10 +1228,9 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class SelfDestruct(BuiltinFunction):
+class SelfDestruct(BuiltinFunctionT):
     _id = "selfdestruct"
     _inputs = [("to", AddressT())]
-    _return_type = None
     _is_terminus = True
     _warned = False
 
@@ -1251,7 +1246,7 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class BlockHash(BuiltinFunction):
+class BlockHash(BuiltinFunctionT):
     _id = "blockhash"
     _inputs = [("block_num", UINT256_T)]
     _return_type = BYTES32_T
@@ -1264,7 +1259,7 @@ def build_IR(self, expr, args, kwargs, contact):
         )
 
 
-class RawRevert(BuiltinFunction):
+class RawRevert(BuiltinFunctionT):
     _id = "raw_revert"
     _inputs = [("data", BytesT.any())]
     _return_type = None
@@ -1286,7 +1281,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b.resolve(IRnode.from_list(["revert", data, len_]))
 
 
-class RawLog(BuiltinFunction):
+class RawLog(BuiltinFunctionT):
     _id = "raw_log"
     _inputs = [("topics", DArrayT(BYTES32_T, 4)), ("data", (BYTES32_T, BytesT.any()))]
 
@@ -1337,7 +1332,7 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class BitwiseAnd(BuiltinFunction):
+class BitwiseAnd(BuiltinFunctionT):
     _id = "bitwise_and"
     _inputs = [("x", UINT256_T), ("y", UINT256_T)]
     _return_type = UINT256_T
@@ -1363,7 +1358,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(["and", args[0], args[1]], typ=UINT256_T)
 
 
-class BitwiseOr(BuiltinFunction):
+class BitwiseOr(BuiltinFunctionT):
     _id = "bitwise_or"
     _inputs = [("x", UINT256_T), ("y", UINT256_T)]
     _return_type = UINT256_T
@@ -1389,7 +1384,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(["or", args[0], args[1]], typ=UINT256_T)
 
 
-class BitwiseXor(BuiltinFunction):
+class BitwiseXor(BuiltinFunctionT):
     _id = "bitwise_xor"
     _inputs = [("x", UINT256_T), ("y", UINT256_T)]
     _return_type = UINT256_T
@@ -1415,7 +1410,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(["xor", args[0], args[1]], typ=UINT256_T)
 
 
-class BitwiseNot(BuiltinFunction):
+class BitwiseNot(BuiltinFunctionT):
     _id = "bitwise_not"
     _inputs = [("x", UINT256_T)]
     _return_type = UINT256_T
@@ -1442,7 +1437,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(["not", args[0]], typ=UINT256_T)
 
 
-class Shift(BuiltinFunction):
+class Shift(BuiltinFunctionT):
     _id = "shift"
     _inputs = [("x", (UINT256_T, INT256_T)), ("_shift_bits", IntegerT.any())]
     _return_type = UINT256_T
@@ -1496,7 +1491,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(b2.resolve(IRnode.from_list(ret, typ=argty)))
 
 
-class _AddMulMod(BuiltinFunction):
+class _AddMulMod(BuiltinFunctionT):
     _inputs = [("a", UINT256_T), ("b", UINT256_T), ("c", UINT256_T)]
     _return_type = UINT256_T
 
@@ -1537,7 +1532,7 @@ class MulMod(_AddMulMod):
     _opcode = "mulmod"
 
 
-class PowMod256(BuiltinFunction):
+class PowMod256(BuiltinFunctionT):
     _id = "pow_mod256"
     _inputs = [("a", UINT256_T), ("b", UINT256_T)]
     _return_type = UINT256_T
@@ -1560,7 +1555,7 @@ def build_IR(self, expr, context):
         return IRnode.from_list(["exp", left, right], typ=left.typ)
 
 
-class Abs(BuiltinFunction):
+class Abs(BuiltinFunctionT):
     _id = "abs"
     _inputs = [("value", INT256_T)]
     _return_type = INT256_T
@@ -1711,7 +1706,7 @@ def _create_preamble(codesize):
     return ["or", bytes_to_int(evm), shl(shl_bits, codesize)], evm_len
 
 
-class _CreateBase(BuiltinFunction):
+class _CreateBase(BuiltinFunctionT):
     _kwargs = {
         "value": KwargSettings(UINT256_T, zero_value),
         "salt": KwargSettings(BYTES32_T, empty_value),
@@ -1940,7 +1935,7 @@ def _build_create_IR(self, expr, args, context, value, salt, code_offset, raw_ar
                 return b1.resolve(b2.resolve(ir))
 
 
-class _UnsafeMath(BuiltinFunction):
+class _UnsafeMath(BuiltinFunctionT):
     # TODO add unsafe math for `decimal`s
     _inputs = [("a", IntegerT.any()), ("b", IntegerT.any())]
 
@@ -2006,7 +2001,7 @@ class UnsafeDiv(_UnsafeMath):
     op = "div"
 
 
-class _MinMax(BuiltinFunction):
+class _MinMax(BuiltinFunctionT):
     _inputs = [("a", (DecimalT(), IntegerT.any())), ("b", (DecimalT(), IntegerT.any()))]
 
     def evaluate(self, node):
@@ -2080,7 +2075,7 @@ class Max(_MinMax):
     _opcode = "gt"
 
 
-class Uint2Str(BuiltinFunction):
+class Uint2Str(BuiltinFunctionT):
     _id = "uint2str"
     _inputs = [("x", IntegerT.unsigneds())]
 
@@ -2152,7 +2147,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(IRnode.from_list(ret, location=MEMORY, typ=return_t))
 
 
-class Sqrt(BuiltinFunction):
+class Sqrt(BuiltinFunctionT):
     _id = "sqrt"
     _inputs = [("d", DecimalT())]
     _return_type = DecimalT()
@@ -2208,7 +2203,7 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
-class ISqrt(BuiltinFunction):
+class ISqrt(BuiltinFunctionT):
     _id = "isqrt"
     _inputs = [("d", UINT256_T)]
     _return_type = UINT256_T
@@ -2258,7 +2253,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(IRnode.from_list(ret, typ=UINT256_T))
 
 
-class Empty(TypenameFoldedFunction):
+class Empty(TypenameFoldedFunctionT):
     _id = "empty"
 
     def fetch_call_return(self, node):
@@ -2273,7 +2268,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode("~empty", typ=output_type)
 
 
-class Breakpoint(BuiltinFunction):
+class Breakpoint(BuiltinFunctionT):
     _id = "breakpoint"
     _inputs: list = []
 
@@ -2291,7 +2286,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list("breakpoint", annotation="breakpoint()")
 
 
-class Print(BuiltinFunction):
+class Print(BuiltinFunctionT):
     _id = "print"
     _inputs: list = []
     _has_varargs = True
@@ -2369,7 +2364,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(ret, annotation="print:" + sig)
 
 
-class ABIEncode(BuiltinFunction):
+class ABIEncode(BuiltinFunctionT):
     _id = "_abi_encode"  # TODO prettier to rename this to abi.encode
     # signature: *, ensure_tuple=<literal_bool> -> Bytes[<calculated len>]
     # explanation of ensure_tuple:
@@ -2486,7 +2481,7 @@ def build_IR(self, expr, args, kwargs, context):
         return IRnode.from_list(ret, location=MEMORY, typ=buf_t)
 
 
-class ABIDecode(BuiltinFunction):
+class ABIDecode(BuiltinFunctionT):
     _id = "_abi_decode"
     _inputs = [("data", BytesT.any()), ("output_type", "TYPE_DEFINITION")]
     _kwargs = {"unwrap_tuple": KwargSettings(BoolT(), True, require_literal=True)}
@@ -2573,7 +2568,7 @@ def build_IR(self, expr, args, kwargs, context):
             return b1.resolve(ret)
 
 
-class _MinMaxValue(TypenameFoldedFunction):
+class _MinMaxValue(TypenameFoldedFunctionT):
     def evaluate(self, node):
         self._validate_arg_types(node)
         input_type = type_from_annotation(node.args[0])
@@ -2607,7 +2602,7 @@ def _eval(self, type_):
         return type_.ast_bounds[1]
 
 
-class Epsilon(TypenameFoldedFunction):
+class Epsilon(TypenameFoldedFunctionT):
     _id = "epsilon"
 
     def evaluate(self, node):