This is a third commit of Issue #2498

Author: lanceherman

vyper/builtins/functions.py

@@ -213,17 +213,32 @@ def _try_fold(self, node):
 
         elif isinstance(target_typedef, AddressT):
             if isinstance(value, vy_ast.Hex):
-                if len(value.value) != 42:  # 0x + 40 hex chars
-                    raise InvalidLiteral("Address must be exactly 20 bytes", node.args[0])
-                result = value.value
+                if not value.value.startswith("0x"):
+                    raise InvalidLiteral("Address must start with 0x", node.args[0])
+                try:
+                    addr_bytes = value.bytes_value
+                    if len(addr_bytes) != 20:
+                        raise InvalidLiteral("Address must be exactly 20 bytes", node.args[0])
+                    result = value.value
+                except ValueError:
+                    raise InvalidLiteral("Invalid hex literal for address", node.args[0])
+            elif isinstance(value, vy_ast.Int):
+                # Convert integer to address (right-padded with zeros)
+                addr_bytes = value.value.to_bytes(32, "big")[-20:]
+                result = f"0x{addr_bytes.hex()}"
             else:
                 raise UnfoldableNode
             return vy_ast.Hex.from_node(node, value=result)
 
         elif isinstance(target_typedef, IntegerT):
-            if not isinstance(value, (vy_ast.Int, vy_ast.Decimal)):
+            if isinstance(value, vy_ast.Decimal):
+                if value.value % 1 != 0:
+                    raise InvalidLiteral("Cannot truncate decimal when converting to integer", node.args[0])
+                result = int(value.value)
+            elif isinstance(value, vy_ast.Int):
+                result = value.value
+            else:
                 raise UnfoldableNode
-            result = int(value.value)
             lo, hi = target_typedef.ast_bounds
             if result < lo or result > hi:
                 raise InvalidLiteral(
@@ -233,12 +248,30 @@ def _try_fold(self, node):
 
         elif isinstance(target_typedef, BytesM_T):
             if isinstance(value, vy_ast.Hex):
-                if len(value.bytes_value) != target_typedef.length:
+                if not value.value.startswith("0x"):
+                    raise InvalidLiteral("Bytes must start with 0x", node.args[0])
+                try:
+                    bytes_value = value.bytes_value
+                    if len(bytes_value) > target_typedef.length:
+                        raise InvalidLiteral(
+                            f"Bytes literal too long for {target_typedef}", node.args[0]
+                        )
+                    # Left-pad with zeros if shorter than target length
+                    if len(bytes_value) < target_typedef.length:
+                        bytes_value = bytes_value.rjust(target_typedef.length, b"\x00")
+                    result = f"0x{bytes_value.hex()}"
+                except ValueError:
+                    raise InvalidLiteral("Invalid hex literal for bytes", node.args[0])
+            elif isinstance(value, vy_ast.Bytes):
+                bytes_value = value.value
+                if len(bytes_value) > target_typedef.length:
                     raise InvalidLiteral(
-                        f"Expected {target_typedef.length} bytes, got {len(value.bytes_value)}", 
-                        node.args[0]
+                        f"Bytes literal too long for {target_typedef}", node.args[0]
                     )
-                result = value.value
+                # Left-pad with zeros if shorter than target length
+                if len(bytes_value) < target_typedef.length:
+                    bytes_value = bytes_value.rjust(target_typedef.length, b"\x00")
+                result = f"0x{bytes_value.hex()}"
             else:
                 raise UnfoldableNode
             return vy_ast.Hex.from_node(node, value=result)
@@ -247,15 +280,13 @@ def _try_fold(self, node):
 
     def fetch_call_return(self, node):
         _, target_typedef = self.infer_arg_types(node)
-
-        # note: more type conversion validation happens in convert.py
         return target_typedef.typedef
 
     def infer_arg_types(self, node, expected_return_typ=None):
         self._validate_arg_types(node)
         possible = sorted(
             get_possible_types_from_node(node.args[0]),
-            key=lambda t: (t.typ, getattr(t, "bits", 0))
+            key=lambda t: (str(t.typ), getattr(t, "bits", 0))
         )
         value_type = possible[0]
         target_type = type_from_annotation(node.args[1])
@@ -419,7 +450,7 @@ def infer_arg_types(self, node, expected_return_typ=None):
         self._validate_arg_types(node)
         possible = sorted(
             get_possible_types_from_node(node.args[0]),
-            key=lambda t: (t.typ, getattr(t, "bits", 0))
+            key=lambda t: (str(t.typ), getattr(t, "bits", 0))
         )
         b_type = possible[0]
         return [b_type, self._inputs[1][1], self._inputs[2][1]]
@@ -950,11 +981,15 @@ def _try_fold(self, node):
             raise UnfoldableNode
 
         if isinstance(output_type, BytesM_T):
+            expected = output_type.length
+            if expected != 32:
+                result = result[:expected]
             return vy_ast.Hex.from_node(node, value=f"0x{result.hex()}")
         elif isinstance(output_type, IntegerT):
             return vy_ast.Int.from_node(node, value=int.from_bytes(result, "big"))
         elif isinstance(output_type, AddressT):
-            return vy_ast.Hex.from_node(node, value=f"0x{result.hex()}")
+            # right-align as per ABI: take the last 20 bytes
+            return vy_ast.Hex.from_node(node, value=f"0x{result[-20:].hex()}")
         else:
             raise UnfoldableNode
 
@@ -967,7 +1002,7 @@ def infer_arg_types(self, node, expected_return_typ=None):
         self._validate_arg_types(node)
         possible = sorted(
             get_possible_types_from_node(node.args[0]),
-            key=lambda t: (t.typ, getattr(t, "bits", 0))
+            key=lambda t: (str(t.typ), getattr(t, "bits", 0))
         )
         input_type = possible[0]
         return [input_type, UINT256_T]