vyperlang-vyper-3925-4060

typing.py
utils.py
venom
version.py
vyper_git_commithash.txt
warnings.py
/repo/vyper/ast/grammar.lark
/repo/vyper/builtins/functions.py

memory_allocator.py
module.py
return_.py
self_call.py
stmt.py

from vyper.semantics.types import DArrayT, SArrayT, _BytestringT
from vyper.semantics.types.shortcuts import UINT256_T


def _is_complex_type(typ):
    # Tuples, Structs, and SArrays follow the same code path
    return is_tuple_like(typ) or isinstance(typ, (SArrayT))


# turn an ir node into a list, based on its type.
def _deconstruct_complex_type(ir_node):
    ir_t = ir_node.typ
    assert _is_complex_type(ir_t)

    if is_tuple_like(ir_t):
        ks = ir_t.tuple_keys()
    else:
        ks = [IRnode.from_list(i, UINT256_T) for i in range(ir_t.count)]

    ret = []
    for k in ks:
        ret.append(get
…[6602 chars omitted]…
(
        "dst"
    ) as (b2, dst):
        dyn_ofst = "dyn_ofst"  # current offset in the dynamic section

        if ir_node.typ._is_prim_word:
            ir_ret.append(make_setter(dst, ir_node))
        elif isinstance(ir_node.typ, _BytestringT):
            # TODO optimize out repeated ceil32 calculation
            ir_ret.append(make_setter(dst, ir_node))
            ir_ret.append(zero_pad(dst))

            raise CompilerPanic(f"unencodable type: {ir_node.typ}")

        # declare IR variables.
        if returns_len:
            if not abi_t.is_dynamic():
                ir_ret.append(abi_t.embedded_static_size())
            elif isinstance(ir_node.typ, _BytestringT):
                # for abi purposes, return zero-padded length
    
…[232 chars omitted]…
        raise CompilerPanic(f"unknown type {ir_node.typ}")

        if abi_t.is_dynamic() and abi_t.is_complex_type():
            dyn_section_start = abi_t.static_size()
            ir_ret = ["with", dyn_ofst, dyn_section_start, ir_ret]
        else:
            pass  # skip dyn_ofst allocation if we don't need it

        return b1.resolve(b2.resolve(IRnode.from_list(ir_ret, annotation=annotation)))

            length = abi_encode(
                add_ofst(buf, 32), encode_input, context, returns_len=True, bufsz=maxlen
            )
            # write the output length to where bytestring stores its length
            ret += [["mstore", buf, length]]

        # return the buf location
        # TO
…[4400 chars omitted]…
validate_arg_types(node)
        input_type = type_from_annotation(node.args[0])

        if not input_type.compare_type(DecimalT()):
            raise InvalidType(f"Expected decimal type but got {input_type} instead", node)

        return vy_ast.Decimal.from_node(node, value=input_type.epsilon)


DISPATCH_TABLE = {
    "_abi_encode": ABIEncode(),
    "_abi_decode": ABIDecode(),
    "floor": Floor(),

        encoding=parent.encoding,
        annotation=f"{parent}{ofst}",
    )


# TODO simplify this code, especially the ABI decoding
def _get_element_ptr_tuplelike(parent, key):
    typ = parent.typ
    assert is_tuple_like(typ)

    if isinstance(typ, StructT):
        assert isinstance(key, str)
        subtype = typ.member_types[key]
        attrs = list(typ.tuple_keys())
        index = attrs.index(key)
        annotation = key
    else:
        # TupleT
        assert isinstance(key, int)
        subt
…[7195 chars omitted]…
ed.
    # https://solidity.readthedocs.io/en/latest/abi-spec.html#function-selector-and-argument-encoding
    # "and the return values v_1, ..., v_k of f are encoded as
    #
    #    enc((v_1, ..., v_k))
    #    i.e. the values are combined into a tuple and encoded.
    # "
    # therefore, wrap it in a tuple if it's not already a tuple.
    # for example, `bytes` is returned as abi-encoded (bytes,)

    return typ


def wrap_value_for_external_return(ir_val):
    # used for LHS promotion
    if needs_external_call_wrap(ir_val.typ):
        return ir_tuple_from_args([ir_val])
    else:
        return ir_val


def set_type_for_external_return(ir_val):
    # used for RHS promotion
    ir_val.typ = calculate_type_for_external_return(ir_val.typ)


# return a dummy IRnode with the given type
def dummy_node_for_typ
…[5395 chars omitted]…
 rethink/streamline the clamp_basetype logic
        if needs_clamp(right.typ, right.encoding):
            with right.cache_when_complex("bs_ptr") as (b, right):
                copier = make_byte_array_copier(left, right)
                ret = b.resolve(["seq", clamp_bytestring(right), copier])
        else:
            ret = make_byte_array_copier(left, right)

        return IRnode.from_list(ret)

            ret = _dynarray_make_setter(left, right)

        return IRnode.from_list(ret)

    # Complex Types
    assert isinstance(left.typ, (SArrayT, TupleT, StructT))

    return _complex_make_setter(left, right)


# locations with no dedicated copy opcode
# (i.e. storage and transient storage)
def copy_opcode_available(left, right
…[4045 chars omitted]…
.resolve(IRnode.from_list(ret)))


def ensure_in_memory(ir_var, context):
    """Ensure a variable is in memory. This is useful for functions
    which expect to operate on memory variables.
    """
    if ir_var.location == MEMORY:
        return ir_var

    typ = ir_var.typ
    buf = IRnode.from_list(context.new_internal_variable(typ), typ=typ, location=MEMORY)
    do_copy = make_setter(buf, ir_var)

            )

            # store new length
            ret.append(ensure_eval_once("append_dynarray", STORE(darray_node, ["add", len_, 1])))

            return IRnode.from_list(b1.resolve(b2.resolve(ret)))


def pop_dyn_array(darray_node
…[1736 chars omitted]…
rent = add_ofst(parent, parent.location.word_scale * DYNAMIC_ARRAY_OVERHEAD)

    ofst_ir = add_ofst(parent, ofst)

    if member_abi_t.is_dynamic():
        # double dereference, according to ABI spec
        # TODO optimize special case: first dynamic item
        # offset is statically known.
        ofst_ir = add_ofst(parent, unwrap_location(ofst_ir))

    return IRnode.from_list(
        ofst_ir,

/repo/tests/functional/syntax/test_abi_decode.py

struct Animal:
  name: String[5]
  address_: address
  id_: int128
  is_furry: bool
  price: decimal
  data: uint256[3]
  metadata: bytes32

struct Human:
  name: String[64]
  pet: Animal

@external
def abi_decode(x: Bytes[160]) -> (address, int128, bool, decimal, bytes32):
    a: address = empty(address)
    b: int128 = 0
    c: bool = False
    d: decimal = 0.0
    e: bytes32 = 0x0000000000000000000000000000000000000000000000000000000000000000
    a, b, c, d, e = _abi_decode(x, (address, int128, bool, decimal, bytes32))
    return 
…[3490 chars omitted]…
52:def test_clamper_nested_uint8(get_contract, tx_failed):
367:def test_clamper_nested_bytes(get_contract, tx_failed):
391:def test_clamper_dynamic(get_contract, tx_failed, output_typ, input_):
407:def test_abi_decode_conditional(get_contract, arg, encoding, expected):
433:def test_clamper_dynamic_tuple(
472:def test_abi_decode_length_mismatch(get_contract, assert_compile_failed, bad_code, exception):

    b: uint256 = empty(uint256)
    a, b = _abi_decode(x, (uint256, uint256))
    return a, b
    """
    c = get_contract(contract)
    with tx_failed():
        c.abi_decode(input_)


def test_clamper_nested_uint8(get_contract, tx_failed):
    # check that _abi_decode clamps on word-types even when it is in a nested expression
    # decode -> validate uint8 -> revert if input >= 256 -> cast back to uint256
    contract = """
@external
def abi_decode(x: uint256) -> uint256:
    a: uint256 = convert(_abi_decode(slic
…[2811 chars omitted]…
input_)


FAIL_LIST = [
    (
        """
@external
def foo(x: Bytes[32]):
    a: uint256 = 0
    b: uint256 = 0
    a, b = _abi_decode(x, (uint256, uint256))
    """,
        StructureException,  # Size of input data is smaller than expected output
    ),
    (
        """
@external
def foo(x: Bytes[32]):
    _abi_decode(x)
    """,
        ArgumentException,  # Output types arg is missing
    ),
]

    _gas: int
    valency: int
    args: List["IRnode"]
    value: Union[str, int]
    is_self_call: bool
    passthrough_metadata: dict[str, Any]
    func_ir: Any
    common_ir: Any

    def __init__(
        self,
        value: Union[str, int],
        args: List["IRnode"] = None,
        typ: VyperType = None,
        location: Optional[AddrSpace] = None,
        ast_source: Optional[vy_ast.VyperNode] = None,
        annotation: Optional[str] = None,
        error_msg: Optional[str] = None,
        mutable: bool = True,
        add_gas_estimate: 
…[1881 chars omitted]…
rough_metadata["alloca"] = self.alloca
/repo/vyper/ir/optimizer.py:444:    passthrough_metadata = node.passthrough_metadata
/repo/vyper/ir/optimizer.py:468:            passthrough_metadata=passthrough_metadata,
/repo/vyper/venom/ir_node_to_venom.py:541:            alloca = ir.passthrough_metadata["alloca"]
/repo/vyper/venom/ir_node_to_venom.py:545:            alloca = ir.passthrough_metadata["alloca"]

136:        stomp_return_buffer.append(make_setter(return_buf, override_value))
137:        unpacker = ["if", ["eq", "returndatasize", 0], stomp_return_buffer, unpacker]
186:    ret_unpacker, ret_ofst, ret_len = _unpack_retur
…[1553 chars omitted]…
        # so allocate enough space here for the returndata too.
        buflen = max(args_abi_t.size_bound(), return_abi_t.size_bound())
    else:
        buflen = args_abi_t.size_bound()

    buflen += 32  # padding for the method id

    buf_t = get_type_for_exact_size(buflen)
    buf = context.new_internal_variable(buf_t)

    args_ofst = add_ofst(buf, 28)
    args_len = args_abi_t.size_bound() + 4

    assert 0 < min_return_size <= max_return_size

    ret_ofst = buf
    ret_len = max_return_size

    encoding = Encoding.ABI

    assert buf.location == MEMORY
    buf = copy.copy(buf)
    buf.typ = wrapped_return_t
    buf.encoding = encoding
    buf.annotation = f"{expr.node_source_code} returndata buffer"

    unpacker = ["seq"]

    # revert when returndatasize is not in bounds
    # (except when return_override is provided.)
    if not call_kwargs.skip_contract_check:
        assertion = IRnode.fro
…[898 chars omitted]…
(_extcodesize_check(contract_address))
        stomp_return_buffer.append(make_setter(return_buf, override_value))
        unpacker = ["if", ["eq", "returndatasize", 0], stomp_return_buffer, unpacker]

    unpacker = ["seq", unpacker, return_buf]

    return unpacker, ret_ofst, ret_len


def _parse_kwargs(call_expr, context):
    from vyper.codegen.expr import Expr  # TODO rethink this circular import

/repo/vyper/builtins/functions.py:2530:                encoding=Encoding.ABI,
/repo/vyper/builtins/functions.py:2533:            to_decode.encoding = Encoding.ABI

from vyper.codegen.stmt import parse_body
from vyper.evm.address_space import CALLDATA, DATA
from vyper.semantics.types import TupleT
from vyper.semantics.types.function import ContractFunctionT
from vyper.utils import calc_mem_gas


# register function args with the local calling context.
# also allocate the ones that live in memory (i.e. kwargs)
def _register_function_args(func_t: ContractFunctionT, context: Context) -> list[IRnode]:
    r
…[2848 chars omitted]…
rhs)
            copy_arg.ast_source = arg_meta.ast_source
            ret.append(copy_arg)

        for x in default_kwargs:
            lhs = context.lookup_var(x.name).as_ir_node()
            lhs.ast_source = x.ast_source
            kw_ast_val = func_t.default_values[x.name]  # e.g. `3` in x: int = 3
            rhs = Expr(kw_ast_val, context).ir_node

            copy_arg = make_setter(lhs, rhs)

460-
461-        for arg in self.args:
462-            ret |= arg.referenced_variables
463-
464-        if getattr(self, "is_self_call", False):
465-            ret |= self.invoked_function_ir.func_ir.referenced_variables
466-
467-        return ret
468-
469-    @cached_property
470-    def contains_risky_call(self):
471-        ret = self.value in ("ca
…[285 chars omitted]…
 ret
480-
481-    @cached_property
482-    def contains_self_call(self):
483-        return getattr(self, "is_self_call", False) or any(x.contains_self_call for x in self.args)
484-
485-    # TODO this seems like a not useful and also confusing function
486-    # check if dead code and remove - CMC 2021-12-13
487-    def to_list(self):
488-        return [self.value] + [a.to_list() for a in self.args]

104:class ABI_Bool(ABI_GIntM):
113:class ABI_BytesM(ABIType):
120:    def is_dynamic(self):
123:    def static_size(self):
129:    def is_complex_type(self):
135:class ABI_Function(ABI_BytesM):
144:class ABI_StaticArray(ABIType):
152:    def is_dynamic(self):
155:    def static_size(self):
167:    def is_complex_type(self):
171:class ABI_Bytes(ABIType):
178:    def is_dynamic(self):
183:    def static_size(self):
196:    def is_complex_type(self):
200:class ABI_String(ABI_Bytes):
205:class ABI_DynamicArray(ABIType):
213:    def is_dynamic(self):
216:    def static_size(self):
231:    def is_complex_type(self):
235:class ABI_Tuple(ABIType):
239:    def is_dynamic(self):
242:    def static_size(self):
251:    def is_complex_type(self):

    # size (in bytes) in the static section (aka 'head')
    # when embedded in a complex type.
    def embedded_static_size(self):
        if self.is_dynamic():
            return 32
        return self.static_size()

    # size bound in the dynamic section (aka 'tail')
    # when embedded in a complex type.
    def embedded_dynamic_size_bound(self):
        if not self.is_dynamic():
            return 0
        return self.size_bound()

    def embedded_min_dynamic_size(self):
        if not self.is_dynamic():
            return 0
        return self.min_size()

    # size (in bytes)
…[3201 chars omitted]…
e() for t in self.subtyps])

    def dynamic_size_bound(self):
        return sum([t.embedded_dynamic_size_bound() for t in self.subtyps])

    def min_dynamic_size(self):
        return sum([t.embedded_min_dynamic_size() for t in self.subtyps])

    def is_complex_type(self):
        return True

    def selector_name(self):
        return "(" + ",".join(t.selector_name() for t in self.subtyps) + ")"

        skip_contract_check=_bool(call_kwargs.pop("skip_contract_check", IRnode(0))),
        default_return_value=call_kwargs.pop("default_return_value", None),
    )

    if len(call_kwargs) != 0:  # pragma: nocover
        raise TypeCheckFailure(f"Unexpected keyword arguments: {call_kwargs}")

    return ret


def _extcodesize_check(address):
    return IRnode.from_list(["assert", ["extcodesize", address]
…[2208 chars omitted]…
ntext)
    assert isinstance(contract_address.typ, InterfaceT)
    args_ir = [Expr(x, context).ir_node for x in call_expr.args]
    call_kwargs = _parse_kwargs(call_expr, context)

    with contract_address.cache_when_complex("external_contract") as (b1, contract_address):
        return b1.resolve(
            _external_call_helper(contract_address, args_ir, call_kwargs, call_expr, context)
        )

        # performance: if the subtype is dynamic, there might be a lot
        # of unused space inside of each element. for instance
        # DynArray[DynArray[uint256, 100], 5] where all the child
        # arrays are empty - for this case, we recursively call
        # into make_setter instead of straight bytes copy
        # TODO we can make this heuristic more precise, e.g.
        # loop when subtype.is_dynamic AND loc
…[3609 chars omitted]…
            copy_op = ["dloadbytes", dst, src, length]
150:def make_byte_array_copier(dst, src):
197:def _dynarray_make_setter(dst, src):
289:def copy_bytes(dst, src, length, length_bound):
377:def get_dyn_array_count(arg):
1058:def zero_pad(bytez_placeholder):
1088:def clamp_bytestring(ir_node):
1096:def clamp_dyn_array(ir_node):
1104:def clamp_basetype(ir_node):
1208:def clamp2(lo, arg, hi, signed):

        if src.typ.maxlen <= 32 and not copy_opcode_available(dst, src):
            # if there is no batch copy opcode available,
            # it's cheaper to run two load/stores instead of copy_bytes
            ret = ["seq"]
            # store length word
            len_ = get_bytearray_length(src)
            ret.append(STORE(dst, len_))

            # store the single data word.
            dst_data_ptr = bytes_data_ptr(dst)
            src_data_ptr = bytes_data_ptr(src)
…[4932 chars omitted]…
turn IRnode.from_list(LOAD(arg), typ=typ)


def append_dyn_array(darray_node, elem_node):
    assert isinstance(darray_node.typ, DArrayT)

    assert darray_node.typ.count > 0, "jerk boy u r out"

    ret = ["seq"]
    with darray_node.cache_when_complex("darray") as (b1, darray_node):
        len_ = get_dyn_array_count(darray_node)
        with len_.cache_when_complex("old_darray_len") as (b2, len_):

/repo/vyper/codegen/module.py:349:                    ["assert", ["iszero", ["or", bad_callvalue, bad_calldatasize]]],

/repo/tests/functional/codegen/calling_convention/test_external_contract_calls.py:1553:    extcall Bar(msg.sender).bar(skip_contract_check=x)

interface Bar:
    def bar() -> uint256: view
    def baz(): nonpayable

@external
def call_bar(addr: address):
    # would fail if returndatasize check were on
    x: uint256 = staticcall Bar(addr).bar(skip_contract_check=True)
@external
def call_baz():
    # some address with no code
    addr: address = 0x1234567890AbcdEF1234567890aBcdef12345678
    # would fail if extcodesize check were on
    extcall Bar(addr).baz(skip_contract_check=True)
    """
    c1 = get_contract(contract_1)
    c2 = get_contract(contract_2)
    c1.call_bar(c2.address)
    c1.call_baz()


def test_invalid_keyword_on_call(assert_compile_failed, get_contract):
    contract_1 = """
interface Bar:
    def set_lucky(ar
…[1190 chars omitted]…
, x: uint256, y: uint256):
    s: uint256 = staticcall Bar(a).bar(x, y=y)
    """,
]


@pytest.mark.parametrize("bad_code", FAILING_CONTRACTS_STRUCTURE_EXCEPTION)
def test_bad_code_struct_exc(assert_compile_failed, get_contract, bad_code):
    assert_compile_failed(lambda: get_contract(bad_code), ArgumentException)


def test_bad_skip_contract_check(assert_compile_failed, get_contract):
    code = """

97-
98-def _mcopy_gas_bound(num_bytes):
99-    return GAS_COPY_WORD * ceil32(num_bytes) // 32
100-
101-
102-def _calldatacopy_gas_bound(num_bytes):
103-    return GAS_COPY_WORD * ceil32(num_bytes) // 32
104-
105-
106-def _codecopy_gas_bound(num_bytes):
107-    return GAS_COPY_WORD * ceil32(num_bytes) // 32
108-
109-
110-def data_location_to_address_space(s: DataLocation, is_ctor_ctx: bool) -> AddrSpace:
111-    if s == DataLocation.MEMORY:
112-        return MEMORY
113-    if s == DataLocation.STORAGE:
114-        return STORAGE
115-    if s == DataLocation.TRANSIENT:

        ret = ["seq", ["assert", ["and", [GE, arg, lo], [LE, arg, hi]]], arg]
        return IRnode.from_list(b1.resolve(ret), typ=arg.typ)

    elif code.value == "if" and len(code.args) == 3:
        o = []
        o.extend(_compile_to_assembly(code.args[0], withargs, existing_labels, break_dest, height))
        mid_symbol = mksymbol("else")
        end_symbol = mksymbol("join")
        o.extend(["ISZERO", mid_symbol, "JUMPI"])
        o.extend(_compile_to_assembly(code
…[520 chars omitted]…
 # }
    elif code.value == "repeat":
        o = []
        if len(code.args) != 5:  # pragma: nocover
            raise CompilerPanic("bad number of repeat args")

        i_name = code.args[0]
        start = code.args[1]
        rounds = code.args[2]
        rounds_bound = code.args[3]
        body = code.args[4]

        entry_dest, continue_dest, exit_dest = (
            mksymbol("loop_start"),

        return 32

    def selector_name(self):
        return ("" if self.signed else "u") + f"int{self.m_bits}"

    def is_complex_type(self):
        return False


# address: equivalent to uint160, except for the assumed interpretation
#   and language typing. For computing the function selector, address is used.
class ABI_Address(ABI_GIntM):
    def __init__(self):
        return super().__init__(160, False)

    def selector_name(self):
        return "address"


# bool: equivalent to uint8 restricted to the values 0 and 1.
#  For computing the function selector
…[1411 chars omitted]…
f.m_elems * self.subtyp.embedded_static_size()

    def dynamic_size_bound(self):
        return self.m_elems * self.subtyp.embedded_dynamic_size_bound()

    def min_dynamic_size(self):
        return self.m_elems * self.subtyp.embedded_min_dynamic_size()

    def selector_name(self):
        return f"{self.subtyp.selector_name()}[{self.m_elems}]"

    def is_complex_type(self):
        return True

        o.extend(_data_ofst_of("_sym_code_end", loc, height + 1))
        o.extend(PUSH(MemoryPositions.FREE_VAR_SPACE) + ["CODECOPY"])
        o.extend(PUSH(MemoryPositions.FREE_VAR_SPACE) + ["MLOAD"])
        return o

    # batch copy from data section of the currently executing code to memory
    # (probably should have named this dcopy but oh well)
    elif code.value == "dloadbytes":
        dst = code.args[0]
        src = code.args[1]
        len_ = code.args[2]

        o = []
        o.extend(_compile_to_assemb
…[886 chars omitted]…
tables" section of memory
# which is read-write in deploy code but then gets turned into
# the "data" section of the runtime code
IMMUTABLES = AddrSpace("immutables", 32, "iload", "istore")
# data addrspace: "data" section of runtime code, read-only.
DATA = AddrSpace("data", 32, "dload", None, "dloadbytes")


def legal_in_staticcall(location: AddrSpace):
    return location not in (STORAGE, TRANSIENT)

ody = ["seq", make_setter(loop_var, e), parse_body(self.stmt.body, self.context)]
/repo/vyper/builtins/functions.py:808:        ret.append(make_setter(input_buf, args_tuple))
/repo/vyper/builtins/functions.py:1289:                ["seq", make_setter(placeholder, data), ensure_eval_once("raw_log", log_ir)]
/repo/vyper/builtins/functions.py:2542:            ret.append(make_setter(output_buf, to_decode))

from vyper.evm.opcodes import version_check
from vyper.exceptions import CompilerPanic, TypeCheckFailure, TypeMismatch
from vyper.semantics.data_locations import DataLocation
from vyper.semantics.types import (
    AddressT,
    BoolT,
    BytesM_T,
    BytesT,
    DArrayT,
    DecimalT,
    HashMapT,
    IntegerT,
    InterfaceT,
    StructT,
    TupleT,
    _BytestringT,
)
from vyper.semantics.types.shortcuts import BYTES32_T, INT256_T, UINT256_T
from vyper.semantics.types.subscriptable import SArrayT
from vyper.semantics.types.user import FlagT
from vyper.utils import GAS_COPY_WORD, GAS_IDENTITY, GAS_IDEN
…[1347 chars omitted]…
 // 32
107:    return GAS_COPY_WORD * ceil32(num_bytes) // 32
286:# NOTE: may pad to ceil32 of `length`! If you ask to copy 1 byte, it may
288:# TODO maybe always pad to ceil32, to reduce dirty bytes bugs
348:        # optimized form of (div (ceil32 len) 32)
350:        n_bound = ceil32(length_bound) // 32
998:                n_words = ceil32(len_) // 32
1066:    # optimized form of ceil32(len) - len:

/repo/vyper/codegen/stmt.py:273:        e = get_element_ptr(iter_list, i, array_bounds_check=False)

            ith_element_ptr = get_element_ptr(right, i, array_bounds_check=False)
            ith_element = unwrap_location(ith_element_ptr)

            if isinstance(right.typ, SArrayT):
                len_ = right.typ.count
            else:
                len_ = get_dyn_array_count(right)

            # Condition repeat loop has to break on.

22-    copy_bytes,
23-    dummy_node_for_type,
24-    ensure_eval_once,
25-    ensure_in_memory,
26-    eval_seq,
27-    get_bytearray_length,
28-    get_type_for_exact_size,
29-    ir_tuple_from_args,
30-    make_setter,
31-    promote_signed_int,
32-    sar,
33-    shl,
34-    shr,
35-    unwrap_location,
36-)
37-from vyper.codegen.expr import Expr
38-from vyper.codegen.ir_node import Encoding, scope_multi
39-from vyper.codegen.keccak256_helper import keccak256_helper
--
240:        with add_ofst(start, length).cache_when_complex("end") as (b2, end):
241-            arithmetic_overflow = ["lt", end, start]
242-            buffer_oob = ["gt", end, src_len]
243-            ok = ["iszero", ["or", arithmetic_overflow, buffer_oob]]
244-            return b1.resolve(b2.resolve(["assert", ok]))
245-
246-
247-def _build_adhoc_slice_node(sub: IRnode, start: IRnode, length: IRnode, context: Context) -> IRnode:
248-    assert length.is_literal, "typechecker failed"

 """

    next_mem: int

    _ALLOCATION_LIMIT: int = 2**64

    def __init__(self, start_position: int = MemoryPositions.RESERVED_MEMORY):
        """
        Initializer.

        Arguments
        ---------
        start_position : int, optional
            The initial offset to use as the free memory pointer. Offsets
            prior to this value are considered permanently allocated.
        """

        elif isinstance(item, bytes):
            ret += len(item)
        else:
            raise ValueError(f"invalid data {type(item)} {item}")

    return ret


@dataclass
class RuntimeHeader:
    label: str
    ctor_mem_size: int
    immutables_len: int

    def __repr__(self):
        return f"<RUNTIME {self.la
…[127 chars omitted]…
lf):
        return f"DATA {self.label}"


def _relocate_segments(assembly):
    # relocate all data segments to the end, otherwise data could be
    # interpreted as PUSH instructions and mangle otherwise valid jumpdests
    # relocate all runtime segments to the end as well
    data_segments = []
    non_data_segments = []
    code_segments = []
    for t in assembly:
        if isinstance(t, list):

    def _height_of(witharg):
        ret = height - withargs[witharg]
        if ret > 16:
            raise Exception("With statement too deep")
        return ret

    if existing_labels is None:
        existing_labels = set()
    if not isinstance(existing_labels, set):
        raise CompilerPanic(f"must be set(), but got {t
…[228 chars omitted]…
the length bytes themselves.
        suffix_len = len(bytecode_suffix) + 2
        bytecode_suffix += suffix_len.to_bytes(2, "big")

    pc += len(bytecode_suffix)

    symbol_map["_sym_code_end"] = pc
    symbol_map["_mem_deploy_start"] = runtime_code_start
    symbol_map["_mem_deploy_end"] = runtime_code_end
    if runtime_code is not None:
        symbol_map["_sym_subcode_size"] = len(runtime_code)

    return f"0x{compiler_data.bytecode.hex()}"
                ^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/functools.py", line 998, in __get__
    val = self.func(instance)
          ^^^^^^^^^^^^^^^^^^^
  File "/repo/vyper/compiler/phases.py", line 253, in byt
…[6063 chars omitted]…
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/vyper/ir/compile_ir.py", line 201, in apply_line_no_wrapper
    ret = func(*args, **kwargs)
          ^^^^^^^^^^^^^^^^^^^^^
  File "/repo/vyper/ir/compile_ir.py", line 770, in _compile_to_assembly
    raise ValueError(f"Weird code element: {type(code)} {code}")
ValueError: Weird code element: <class 'vyper.codegen.ir_node.IRnode'> _sym_code_end

E                  5

vyper/builtins/functions.py:2503: StructureException
=========================== short test summary info ============================
FAILED tests/functional/scratch_repro.py::test_zero_len_ok - vyper.exceptions...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 3 passed in 14.23s

        assert abi_min_size <= abi_size_bound, "bad abi type"
--
        return _abi_decode(x, DynArray[uint256, 3])
        """
        c = get_contract(code)
        # empty dynarray, exactly 32 bytes
        encoded = abi.encode("(uint256[])", ([],))
>       assert len(encoded) == 32
E       AssertionError: assert 64 == 32
E        +  where 64 = len(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00...00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x
…[10 chars omitted]…
\x00\x00\x00\x00\x00\x00')

tests/functional/scratch_repro.py:20: AssertionError
=========================== short test summary info ============================
FAILED tests/functional/scratch_repro.py::test_nested_dynarray_oob - vyper.ex...
FAILED tests/functional/scratch_repro.py::test_bytes_len_oob - vyper.exceptio...
FAILED tests/functional/scratch_repro.py::test_zero_len_ok - AssertionError: ...

    abi, bytecode = _compile(source_code, output_formats, input_bundle, compiler_settings)
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/evm_backends/base_env.py:215: in _compile
    out = compile_code(
vyper/compiler/__init__.py:158: in compile_code
    return compile_from_file_input(file
…[1392 chars omitted]…
uint256, 3], 3])
E             ------------------------------^
E                  5

vyper/builtins/functions.py:2503: StructureException
______________________________ test_bytes_len_oob ______________________________
[gw10] linux -- Python 3.12.13 /usr/local/bin/python

get_contract = <function get_contract.<locals>.fn at 0x74a4bd36ec00>
tx_failed = <function tx_failed.<locals>.fn at 0x74a4bd36ede0>

>       c = get_contract(code)
            ^^^^^^^^^^^^^^^^^^

tests/functional/scratch_repro.py:62: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/conftest.py:235: in fn

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/eth/codecs/abi/encoder.py", line 46, in encode
    return node.accept(cls, value)
           ^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/eth/codecs/abi/nodes.py", line 44
…[482 chars omitted]…
n3.12/site-packages/eth/codecs/abi/nodes.py", line 44, in accept
    return fn(self, *args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/eth/codecs/abi/encoder.py", line 247, in visit_IntegerNode
    raise EncodeError(str(node), value, e.args[0])
eth.codecs.abi.exceptions.EncodeError: Error encoding [] as 'uint256' - Value not an instance of type 'int'

	modified:   vyper/codegen/function_definitions/external_function.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	tests/functional/scratch_repro.py

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (9386d2980263774f8dad0c977b0d300a49244eae)

	modified:   vyper/codegen/external_call.py
	modified:   vyper/codegen/function_definitions/external_function.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	tests/functional/scratch_repro.py

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (87fba429b90b804205c2cba21903d73df928150c)

tests/functional/scratch_dbg.py:9: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/evm_backends/abi_contract.py:207: in __call__
--
    super()._parse_revert(output_bytes, e, int(gas_used))
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

output_bytes = b''
error = RuntimeError('Revert { gas_used: 21887, output: 0x }'), gas_used = 21887

    @staticmethod
    def _parse_revert(output_bytes: bytes, error: Excepti
…[553 chars omitted]…
core.py
	modified:   vyper/codegen/external_call.py
	modified:   vyper/codegen/function_definitions/external_function.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	tests/functional/scratch_dbg.py
	tests/functional/scratch_repro.py

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (99287219490865a6f413f6cf11dc8a6446497ad3)

        if not spec.contains(__version__, prereleases=True):
>           raise VersionException(
                f'Version specification "{version_str}" is not compatible '
                f'with compiler version "{__version__}"',
                full_source_code,
                *start,
            )
E           vyper.exceptions.VersionException: Version specification ">0.3.10" is not compatible with compiler version "0.1"
E           
E             line 1:0 
E             ---> 1 #pragma version >0.3.10
E             -------^
E                  2

vyper/ast/pre_parser.py:43: VersionException
=========================== short test summary info ============================
ERROR tests/functional/codegen/calling_convention/test_erc20_abi.py::test_initial_state
1 error in 13.30s

        """
        if output_bytes[:4] == method_id("Error(string)"):
            (msg,) = abi_decode("(string)", output_bytes[4:])
            raise ExecutionReverted(f"{msg}", gas_used) from error
    
>       raise ExecutionReverted(f"0x{outp
…[534 chars omitted]…
(receiver: address, amount: uint256):
    ---> 4     selfdestruct(msg.sender)
    -----------^
         5
  
    vyper_warn(

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
=========================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]

2517-    c1 = get_contract(code)
2518-    sig = method_id(f"foo({typ}[],string)").hex()
2519-    encoded = abi.encode(f"({typ}[],string)", val).hex()
2520-    data = f"0x{sig}{encoded}"
2521-
2522-    # Dynamic size is short by 1 byte
2523-    malformed = data[:264]
2524-    with tx_failed():
2525-        env.message_call(c1.address, data=malformed)
2526-
2527-    # Dynamic size is at least minimum (132 bytes * 2 + 2 (for 0x) = 266)
2528-    valid = data[:266]
2529-    env.message_call(c1.address, data=valid)
2530-
2531-
2532-def test_make_setter_external_call(get_contract):
2533-    # variant of GH #3503
2534-    code = """
2535-interface A:
2536-   def boo() -> uint256:nonpayable
2537-
2538-a: DynArray[uint256, 10]
2539-
2540-@external