vyperlang-vyper-3925-4059

quicktest.sh
requirements-docs.txt
setup.cfg
setup.py
tests
vyper

 pop_dyn_array,
vyper/codegen/expr.py:478:                len_ = get_dyn_array_count(right)
vyper/codegen/expr.py:688:                return pop_dyn_array(darray, return_popped_item=return_item)
vyper/codegen/expr.py:694:                return append_dyn_array(darray, arg)
vyper/codegen/stmt.py:12:    get_dyn_array_count,
vyper/codegen/stmt.py:278:            array_len = get_dyn_array_count(iter_list)

memory_allocator.py
module.py
return_.py
self_call.py
stmt.py
vyper/builtins/functions.py:2466:    _id = "_abi_decode"
vyper/builtins/functions.py:2505:                    "Mismatch between size of input and size of decoded types. "
vyper/builtins/functions.py:2514:        with data.cache_when_complex("to_decode") as (b1, data):
vyper/builtins/functions.py:2526:            to_decode = IRnode.from_list(
vyper/builtins/functions.py:2531:                annotation=f"abi_decode({output_typ})",
vyper/builtins/functions.py:2533:            to_decode.encoding = Encoding.ABI
vyper/builtins/functions.py:2542:            ret.append(make_setter(output_buf, to_decode))
vyper/builtins/functions.py:2604:    "_abi_decode": ABIDecode(),

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
…[8629 chars omitted]…
        n_bound = ceil32(length_bound) // 32

        dst_i = add_ofst(dst, _mul(i, dst.location.word_scale))
        src_i = add_ofst(src, _mul(i, src.location.word_scale))

        copy_one_word = STORE(dst_i, LOAD(src_i))

        main_loop = ["repeat", i, 0, n, n_bound, copy_one_word]

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

    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,
        typ=member_t,
        location=parent.location,
        encoding=parent
…[8629 chars omitted]…
      should_batch_copy = (
                    base_unroll_cost + (nth_word_cost * (n_words - 1)) >= identity_base_cost
                )

            # calldata to memory, code to memory, cancun, or opt-codesize -
            # batch copy is always better.
            else:
                should_batch_copy = True

        if should_batch_copy:
            return copy_bytes(left, right, len_, len_)

def STORE(ptr: IRnode, val: IRnode) -> IRnode:
    if ptr.location is None:  # pragma: nocover
        raise CompilerPanic("cannot dereference non-pointer type")
    op = ptr.location.store_op
    if op is None:  # pragma: nocover
        raise CompilerPanic(f"unreachable {ptr.location}")

    store = [op, ptr, val]
    # don't use eval_once_chec
…[8629 chars omitted]…
s, the bits above bit 128 should be equal.
            # (this works for both val >= 0 and val < 0. in the first case,
            # all upper bits should be 0 if val is a valid int128,
            # in the latter case, all upper bits should be 1.)
            assertion = ["assert", ["eq", val, promote_signed_int(val, bits)]]
        else:
            assertion = ["assert", ["iszero", shr(bits, val)]]

# returns True if t is ABI encoded and is a type that needs any kind of
# validation
def needs_clamp(t, encoding):
    if encoding == Encoding.VYPER:
        return False
    if encoding != Encoding.ABI:  # pragma: nocover
        raise CompilerPanic("unreachable")
    if isinstance(t, (_BytestringT, DArrayT)):
        return True
    if isinstance(t, FlagT):
        return len(t._flag_members) < 256
    if isinstance(t, SArrayT):
        return needs_clamp(t.value_type, encoding)
    if is_tuple_like(t):
        return any(needs_clamp(m, encoding) for m in t.tuple_members())
    if t._is_prim_word:
        return t not in (INT256_T, UINT256_T, BYTES32_T)

    rais
…[5500 chars omitted]…
   should_batch_copy = True

        if should_batch_copy:
            return copy_bytes(left, right, len_, len_)

    # general case, unroll
    with left.cache_when_complex("_L") as (b1, left), right.cache_when_complex("_R") as (b2, right):
        for k in keys:
            l_i = get_element_ptr(left, k, array_bounds_check=False)
            r_i = get_element_ptr(right, k, array_bounds_check=False)

tests/functional/codegen/types/test_dynamic_array.py:991:        self.my_array.append(self.some_var)
tests/functional/codegen/types/test_dynamic_array.py:1002:        self.my_array.append(x)
tests/functional/codegen/types/test_dynamic_array.py:1016:        self.my_array.append(x)
tests/functional/codegen/types/test_dynamic_array.py:1028:        self.my_array.append(x)

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 
…[8629 chars omitted]…
(get_contract, arg, encoding, expected):
    contract = """
@external
def abi_decode(x: Bytes[160]) -> uint256:
    if len(x) == 32:
        a: uint256 = _abi_decode(x, uint256)
        return a
    elif len(x) == 160:
        b: DynArray[uint256, 3] = _abi_decode(x, DynArray[uint256, 3])
        return b[2]
    return 0
    """
    c = get_contract(contract)
    encoded = abi.encode(encoding, (arg,))

@pytest.mark.parametrize("unwrap_tuple", (True, False))
def test_abi_decode_nested_dynarray(get_contract, args, unwrap_tuple):
    if unwrap_tuple is True:
        encoded = abi.encode("(uint256[][])", (args,))
        len = 544
    else:
        encoded = abi.encode("uint256[][]", args)
        len = 512

    code = f"""
@external
def abi_decode(x: Bytes[{len}]) -> DynArray[DynArray[uint256, 3], 3]:
    a: DynArray[DynArray[uint256, 3], 3] = []
    a = _abi_decode(x, DynArray[DynArray[uint256, 3], 3], unwrap_tuple={unwrap_tuple})
    return a
    """

    c = get_contract(code)
    assert c.abi_decode(encoded) == args


…[4709 chars omitted]…
len(xs) - 1:
            break
        ys.append(x)
        i += 1

    return ys
    """,
        lambda xs: xs[:-1],
    ),
    # check overflow
    (
        """
my_array: DynArray[uint256, 5]
@external
def foo(xs: DynArray[uint256, 6]) -> DynArray[uint256, 5]:
    for x: uint256 in xs:
        self.my_array.append(x)
    return self.my_array
    """,
        lambda xs: None if len(xs) > 5 else xs,

            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
…[8629 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)
        )

    eval_once_check,
    get_type_for_exact_size,
    make_setter,
    needs_clamp,
    unwrap_location,
    wrap_value_for_external_return,
)
from vyper.codegen.ir_node import Encoding, IRnode
from vyper.evm.address_space import MEMORY
from vyper.exceptions import TypeCheckFailure
from vyper.semantics.types import InterfaceT, TupleT
from vyper.semantics.types.function import StateMutability


@dataclass
class _CallKwargs:
    value: IRnode
    gas: IRnode
    skip_contract_check: bool
    default_return_value: IRnode


def _pack_arguments(fn_type, args, context):
    # abi encoding just treats a
…[6239 chars omitted]…
:
        call_op = ["staticcall", gas, contract_address, args_ofst, args_len, buf, ret_len]
    else:
        call_op = ["call", gas, contract_address, value, args_ofst, args_len, buf, ret_len]

    ret.append(check_external_call(call_op))

    return_t = fn_type.return_type
    if return_t is not None:
        ret.append(ret_unpacker)

    return IRnode.from_list(ret, typ=return_t, location=MEMORY)

        raise CompilerPanic("tried to modify non-pointer type")
    assert isinstance(ptr.typ, DArrayT)
    return add_ofst(ptr, ptr.location.word_scale)


def _dynarray_make_setter(dst, src):
    assert isinstance(src.typ, DArrayT)
    assert isinstance(dst.typ, DArrayT)

    if src.value == "~empty":
        return IRnode.from_list(STORE(dst, 0))

    # copy contents of src dynarray to dst.
    # note that in case src and dst refer to the same dynarray,
    # in order for get_element_ptr oob checks on the src dynarray
    # to work, we need to wa
…[8327 chars omitted]…
presenting a memory or storage location, and descend down to
# an element or member variable
# This is analogous (but not necessarily equivalent to) getelementptr in LLVM.
def get_element_ptr(parent, key, array_bounds_check=True):
    with parent.cache_when_complex("val") as (b, parent):
        typ = parent.typ

        if is_tuple_like(typ):
            ret = _get_element_ptr_tuplelike(parent, key)

vyper/abi_types.py:46:        return self.static_size() + self.min_dynamic_size()
vyper/abi_types.py:80:    def static_size(self):
vyper/abi_types.py:123:    def 
…[4983 chars omitted]…
 ret[sig] = EntryPointInfo(func_t, calldata_min_size, ir_node)
vyper/codegen/function_definitions/external_function.py:135:    sig, calldata_min_size, ir_node = handler_for(keyword_args, [])
vyper/codegen/function_definitions/external_function.py:138:    ret[sig] = EntryPointInfo(func_t, calldata_min_size, ir_node)
vyper/codegen/return_.py:61:        maxlen = external_return_type.abi_type.size_bound()

    # 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)
…[5848 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) + ")"

setup.py:54:    return re.sub(r"\.dev\d+", "", version_str)
setup.py:61:# version into version.py. (and we need that version to be PEP440 compliant
setup.py:63:# separately, in order so that we can add it to `vyper --version`.
setup.py:75:    use_scm_version={
setup.py:76:        "local_scheme": _local_version,
setup.py:77:        "version_scheme": _global_version,
setup.py:78:        "write_to": "vyper/version.py",
py
…[615 chars omitted]…
 [
        "black==23.12.0",
        "flake8==6.1.0",
        "flake8-bugbear==23.12.2",
        "flake8-use-fstring==1.4",
        "isort==5.13.2",
        "mypy==1.5",
    ],
    "dev": ["ipython", "pre-commit", "pyinstaller", "twine"],
}

extras_require["dev"] = extras_require["dev"] + extras_require["test"] + extras_require["lint"]

with open("README.md", "r") as f:
    long_description = f.read()

from vyper.semantics.types import VyperType
from vyper.utils import VALID_IR_MACROS, ceil32

# Set default string representation for ints in IR output.
AS_HEX_DEFAULT = False

if VYPER_COLOR_OUTPUT:
    OKBLUE = "\033[94m"
    OKMAGENTA = "\033[35m"
    OKLIGHTMAGENTA = "\033[95m"
    OKLIGHTBLUE = "\033[94m"
    ENDC = "\033[0m"
else:
    OKBLUE = ""
    OKMAGENTA = ""
    OKLIGHTMAGENTA = ""
    OKLIGHTBLUE = ""
    ENDC = ""


class NullAttractor(int):
    def __add__(self, other: int) -> "NullAttractor":

…[8629 chars omitted]…
de(4, location=CALLDATA, typ=base_args_t, encoding=Encoding.ABI)
vyper/codegen/function_definitions/external_function.py:36:        if needs_clamp(arg.typ, Encoding.ABI):
vyper/codegen/function_definitions/external_function.py:52:                encoding=Encoding.ABI,
vyper/codegen/function_definitions/external_function.py:79:            4, location=CALLDATA, typ=calldata_args_t, 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
…[4496 chars omitted]…
me_info

    mem_expansion_cost = calc_mem_gas(frame_info.mem_used)
    common_ir.add_gas_estimate += mem_expansion_cost
    func_t._ir_info.gas_estimate = common_ir.gas


def generate_ir_for_external_function(code, compilation_target):
    # TODO type hints:
    # def generate_ir_for_external_function(
    #    code: vy_ast.FunctionDef,
    #    compilation_target: ModuleT,
    # ) -> IRnode:
    """

    # the ir which comprises the main body of the function,
    # besides any kwarg handling
    func_common_ir = IRnode.from_list(["seq", body, exit_], ast_source=code)

    tag_frame_info(func_t, context)

    _adjust_gas_estimate(func_t, func_common_ir)

    return ExternalFuncIR(entry_points, func_common_ir)

        pass

    # MUST be called at the end of building the expression
    # in order to make sure the expression gets wrapped correctly
    def resolve(self, body):
        if self.should_inline:
            # uses of the variable have already been inlined
            return body

        ret = ["with", self.ir_var, self.ir_node, body]
        if isinstance(body, IRnode):
            return IRnode.from_list(
                ret, typ=body.typ, location=body.location, encoding=body.encoding
            )
        else:
            return ret


# Data structure for IR
…[8629 chars omitted]…
623:                passthrough_metadata=passthrough_metadata,
vyper/ir/optimizer.py:444:    passthrough_metadata = node.passthrough_metadata
vyper/ir/optimizer.py:468:            passthrough_metadata=passthrough_metadata,
vyper/venom/ir_node_to_venom.py:541:            alloca = ir.passthrough_metadata["alloca"]
vyper/venom/ir_node_to_venom.py:545:            alloca = ir.passthrough_metadata["alloca"]

        ) and not has_inner_newlines

        if should_output_single_line:
            return output_on_one_line
        else:
            return output

    def __repr__(self):
        return self.repr()

    @classmethod
    def from_list(
        cls,
        obj: Any,
        typ: VyperType = None,
        location: Optional[AddrSpace] = None,
        ast_source:
…[6897 chars omitted]…
tructor, or called from the constructor
        self.is_ctor_context = is_ctor_context

        self.settings = get_global_settings()

    def is_constant(self):
        return self.constancy is Constancy.Constant or self.in_range_expr

    def check_is_not_constant(self, err, expr):
        if self.is_constant():
            raise StateAccessViolation(f"Cannot {err} from {self.pp_constancy()}", expr)

    return IRnode.from_list(LOAD(arg), typ=typ)


# get the number of elements at runtime
def get_dyn_array_count(arg):
    assert isinstance(arg.typ, DArrayT)

    typ = UINT256_T

    if arg.value == "multi":
        return IRnode.from_list(len(arg.args), typ=typ)

    if arg.value == "~empty":
        # empty(DynArray[...])
        return IRnode.from_list(0, typ=typ)

    return IRnode.from_list(LOAD(arg), typ=typ)


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

    
…[4568 chars omitted]…
 call_node.func._metadata["type"]

        if isinstance(func_t, BuiltinFunctionT):
            return func_t.build_IR(call_node, context)

        return external_call.ir_for_external_call(call_node, context)

    def parse_ExtCall(self):
        return self.handle_external_call(self.expr, self.context)

    def parse_StaticCall(self):
        return self.handle_external_call(self.expr, self.context)

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
…[2684 chars omitted]…
 arg_lineno != prev_lineno and self.value in ("seq", "if"):
grep: vyper/codegen/core.py:392:def append_dyn_array(darray_node, elem_node):
vyper/codegen/expr.py:8:    append_dyn_array,
vyper/codegen/expr.py:694:                return append_dyn_array(darray, arg)
vyper/codegen/__pycache__/core.cpython-312.pyc: binary file matches
grep: vyper/codegen/__pycache__/expr.cpython-312.pyc: binary file matches

    if s in (IMMUTABLES, DATA):
        return DataLocation.CODE
    if s == CALLDATA:
        return DataLocation.CALLDATA

    raise CompilerPanic("unreachable!")  # pragma: nocover


def writeable(context, ir_node):
    assert ir_node.is_pointer  # sanity check

    if context.is_constant() and not legal_in_staticcall(ir_node.location):
        return False
    return ir_node.mutable


# Copy byte array word-for-word (including layout)
# TODO make this a private function
def make_byte_array_copier(dst, src):
    assert isinstance(src.typ, _BytestringT)
    assert isi
…[1302 chars omitted]…
rt isinstance(ptr.typ, _BytestringT)
    return add_ofst(ptr, ptr.location.word_scale)


def dynarray_data_ptr(ptr):
vyper/codegen/core.py:1188:def clamp(op, arg, bound):
vyper/codegen/core.py:1208:def clamp2(lo, arg, hi, signed):
vyper/codegen/core.py:1188:def clamp(op, arg, bound):
vyper/codegen/core.py:1208:def clamp2(lo, arg, hi, signed):
vyper/codegen/core.py:1208:def clamp2(lo, arg, hi, signed):

    function_defs = [fn_t.ast_def for fn_t in runtime_reachable]

    runtime_functions = [f for f in function_defs if not _is_constructor(f)]
    internal_functions = [f for f in runtime_functions if _is_internal(f)]
    external_functions = [
        f for f in runtime_functions if not _is_internal(f) and not _is_fallback(f)

508:        deploy_code.extend(ctor_internal_func_irs)
513:        deploy_code.append(["deploy", 0, runtime, 0])
529:    return IRnode.from_list(deploy_code), I
…[4175 chars omitted]…
n_t = func_ast._metadata["func_type"]
        if fn_t.is_internal:
            to_visit.update(fn_t.reachable_internal_functions)
            to_visit.add(fn_t)

    for fn_t in to_visit:
        if fn_t._ir_info is None:
            id_generator.ensure_id(fn_t)
            _ = _ir_for_internal_function(fn_t.ast_def, module_t, False)

    return IRnode.from_list(deploy_code), IRnode.from_list(runtime)

from vyper.compiler.settings import _is_debug_mode
from vyper.exceptions import CompilerPanic
from vyper.semantics.types.module import ModuleT
from vyper.utils import OrderedSet, method_id_int


# calculate globally reachable functions to see which
# ones should make it into the final bytecode.
def _runtime_reachable_functions(module_t, id_generator):
    ret = OrderedSet()

    for fn_t in module_t.exposed_functions:
        assert isinstance(fn_t.ast_def, vy_ast.FunctionDef)

        ret.update(fn_t.reachable_internal_functi
…[1679 chars omitted]…
 ret.append(["goto", func_t._ir_info.external_function_base_entry_label])
    ret.append(func_ir.common_ir)

    return IRnode.from_list(ret)


def _ir_for_internal_function(func_ast, *args, **kwargs):
    return generate_ir_for_internal_function(func_ast, *args, **kwargs).func_ir


def _generate_external_entry_points(external_functions, module_t):
    entry_points = {}  # map from ABI sigs to ir code

vyper/ir/optimizer.py:661:            argz[i] = IRnode.f
…[363 chars omitted]…
ptimizer.py:325:    # TODO: check me! reduce codesize for negative numbers
vyper/ir/optimizer.py:362:    # can't improve gas but can improve codesize
vyper/ir/optimizer.py:367:        # equal gas, but better codesize
vyper/ir/optimizer.py:507:    # may be hand optimized for codesize. we can optimize bitwise ops
vyper/ir/optimizer.py:508:    # more, once we have a pipeline which optimizes for codesize.

            "POP",
        ]

    # Pass statements
    # TODO remove "dummy"; no longer needed
    elif code.value in ("pass", "dummy"):
        return []

    # "mload" from data section of the currently executi
…[802 chars omitted]…
"_sym_code_end", src, height + 1))
        o.extend(_compile_to_assembly(dst, withargs, existing_labels, break_dest, height + 2))
        o.extend(["CODECOPY"])
        return o

    # "mload" from the data section of (to-be-deployed) runtime code
    elif code.value == "iload":
        loc = code.args[0]

        o = []
305:        # codecopy 32 bytes to FREE_VAR_SPACE, then mload from FREE_VAR_SPACE

254-        ret = height - withargs[witharg]
255-        if ret > 16:
256-            raise Exception("With statement too deep")
257-        return ret
258-
259-    if existing_labels is None:
260-        existing_labels = set()
261-    if not isinstance(existing_labels, set):
262-        raise CompilerPanic(f"must be set(), but g
…[1818 chars omitted]…
 = None, None, None
1202:            runtime_code_start, runtime_code_end = _runtime_code_offsets(
1205:            assert runtime_code_end - runtime_code_start == len(runtime_code)
1210:    if runtime_code_end is not None:
1211:        mem_ofst_size = calc_mem_ofst_size(runtime_code_end + max_mem_ofst)
1296:    symbol_map["_sym_code_end"] = pc
1298:    symbol_map["_mem_deploy_end"] = runtime_code_end

        elif is_ofst(item):
            assert is_symbol(assembly[i + 1]) or is_mem_sym(assembly[i + 1])
            assert isinstance(assembly[i + 2], int)
            # [_OFST, _sym_foo, bar] -> PUSH2 (foo+bar)
            # [_OFST, _mem_foo, bar] -> PUSHN (foo+bar)
            pc -= 1
        elif isinstance(item, list) and isinstance(item[0], RuntimeHeader):
            # we are in initcode
           
…[2972 chars omitted]…
:    ctor_args = (2**127 - 1).to_bytes(32, "big")
tests/functional/codegen/features/test_constructor.py:107:    env._deploy(bytecode + ctor_args, value=0)
tests/functional/codegen/features/test_constructor.py:153:def test_nested_dynamic_array_constructor_arg(env, get_contract):
tests/functional/codegen/features/test_constructor.py:169:def test_nested_dynamic_array_constructor_arg_2(env, get_contract):

vyper/codegen/module.py:446:        selector_section = _selector_section_dense(external_functions, module_t)
vyper/codegen/module.py:448:        selector_section = _selector_section_sparse(external_functions, module_t)
vyper/codegen/module.py:457:    runtime = ["seq", selector_section]
431:VALID_IR_MACROS = {

    "assert",
    "break",
    "iload",
    "istore",
    "dload",
    "dloadbytes",
    "ceil32",
    "continue",
    "debugger",
    "ge",
    "if",
    "select",
    "le",
    "deploy",
    "ne",
    "pass",
    "repeat",
    "seq",
    "set",
    "sge",
    "sha3_32",
    "sha3_64",
    "sle",
    "with",
    "label",
    "goto",
    "djump",  # "dynamic jump", i.e. constrained, multi-destination jump
    "~extcode",
    "~selfcode",
    "~calldata",
    "~empty",
    "var_list",
}


EIP_170_LIMIT = 0x6000  # 24kb
ERC5202_PREFIX = b"\xFE\x71\x00"  # default prefix from ERC-5202

SHA3_BASE = 30
90:    return ["if", ["iszero", call_ir], propagate_revert_ir]

    written in a more generic way.

    Attributes:
        name: human-readable nickname for the address space
        word_scale: a constant which helps calculate offsets in a given
            address space. 1 for word-addressable locations (storage),
            32 for byte-addressable locations (memory, calldata, code)
        load_op: the opcode for loading a word from this address space
        store_op: the opcode for storing a word to this address space
            (an address space is read-only if store_op is Non
…[899 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)

+            encoding=ir_node.encoding,
+            passthrough_metadata=ir_node.passthrough_metadata.copy(),
         )
 
     def __enter__(self):
@@ -121,7 +125,11 @@ class _WithBuilder:
         ret = ["with", self.ir_var, self.ir_node, body]
         if isinstance(body, IRnode):
             return IRnode.from_list(
-                ret, typ=body.typ, location=body.location, encoding=body.encoding
+                ret,
+                typ=body.typ,
+                location=body.location,
+                encoding=body.encoding,
+                passthrough_metadata=body.passthrough_metadata.copy(),
             )
         else:
             return ret

from vyper.semantics.types.user import FlagT
from vyper.utils import GAS_COPY_WORD, GAS_IDENTITY, GAS_IDENTITYWORD, ceil32

DYNAMIC_ARRAY_OVERHEAD = 1

# metadata key for the bounds of an ABI-encoded input buffer.
# the value is a dict with `start`, `length`, and `end` IR nodes.
ABI_BUFFER_METADATA = "abi_buffer"


def get_abi_buffer(ir_node):
    return ir_node.passthrough_metadata.get(ABI_BUFFER_METADATA)


def set_abi_buffer(ir_node, start, length, end=None):
    """
    Attach the bounds of the ABI-encoded buffer being decoded to `ir_node`.

    `start` is the absolute location of the first byte of the buffer and
    `length` 
…[1811 chars omitted]…
s_m_type(typ):
    return isinstance(typ, BytesM_T)


def is_numeric_type(typ):
    return isinstance(typ, (IntegerT, DecimalT))


def is_integer_type(typ):
    return isinstance(typ, IntegerT)


def is_decimal_type(typ):
    return isinstance(typ, DecimalT)


def is_flag_type(typ):
    return isinstance(typ, FlagT)


def is_tuple_like(typ):
    # A lot of code paths treat tuples and structs similarly

    metadata = parent.passthrough_metadata.copy()
    if not member_abi_t.is_dynamic():
        return IRnode.from_list(
            ["seq", *checks, ofst_ir],
            typ=member_t,
            location=head_base.location,
            encoding=head_base.encoding,
            annotation=f"{head_base}{ofst}",
            passthrough_metadata=metadata,
        )

    # The head contains an offset to the tail.  Check the head is in
    # bounds before loading it, then check both the offset and 
…[2300 chars omitted]…
:
        t = typ.member_types[attrs[i]]
        ofst += t.get_size_in(data_location)

    return IRnode.from_list(
        add_ofst(parent, ofst),
        typ=subtype,
        location=parent.location,
        encoding=parent.encoding,
        annotation=annotation,
    )


def has_length_word(typ):
    # Consider moving this to an attribute on typ
    return isinstance(typ, (DArrayT, _BytestringT))

                        ret.append(b2.resolve(inner))
   
…[2859 chars omitted]…
 right.is_pointer and right.encoding == Encoding.VYPER:
        # both left and right are pointers, see if we want to batch copy
        # instead of unrolling the loop.
        assert left.encoding == Encoding.VYPER
        len_ = left.typ.memory_bytes_required

        # special logic for identity precompile (pre-cancun) in the else branch
        mem2mem = left.location == right.location == MEMORY

    assert ir_node.is_pointer  # sanity check

    if context.is_constant() and not legal_in_staticcall(ir_node.location):
        return False
    return ir_node.mutable


# Copy byte array word-for-word (including layout)
# TODO make this a private function
def make_byte_array_copier(dst, src):
    assert isinstance(src.typ, _BytestringT)
    assert isinstance(dst.typ, _BytestringT)

    _check_assign_bytes(dst, src)

    # TODO: remove this branch, copy_bytes and get_bytearray_length should handle
    if src.value == "~empty" or src.typ.maxlen == 0:
        # set length w
…[322 chars omitted]…
            # store length word
            len_ = get_bytearray_length(src)
            with len_.cache_when_complex("bs_len") as (b2, len_):
                ret.append(STORE(dst, len_))

                # store the single data word.
                dst_data_ptr = bytes_data_ptr(dst)
                src_data_ptr = bytes_data_ptr(src)
                copy_data = STORE(dst_data_ptr, LOAD(src_data_ptr))

    IRnode,
    add_ofst,
    bytes_data_ptr,
    calculate_type_for_external_return,
    check_external_call,
    clamp,
    clamp2,
    clamp_basetype,
    clamp_nonzero,
    copy_bytes,
    dummy_node_for_type,
    ensure_eval_once,
    ensure_in_memory,
    eval_seq,
    get_bytearray_length,
    get_type_for_exact_size,
    ir_tuple_from_args,
    make_setter,
    promote_signed_int,
    sar,
    shl,
    shr,
    unwrap_location,
)
from vyper.codegen.expr import Expr
from vyper.codegen.ir_node import Encoding, scope_multi
from vyper.codegen.keccak256_helper 
…[1911 chars omitted]…
l,
47-    InvalidType,
48-    StateAccessViolation,
49-    StructureException,
50-    TypeMismatch,
51-    UnfoldableNode,
52-    ZeroDivisionException,
53-)
54-from vyper.semantics.analysis.base import Modifiability, VarInfo
55-from vyper.semantics.analysis.utils import (
56-    get_common_types,
57-    get_exact_type_from_node,
58-    get_possible_types_from_node,
59-    validate_expected_type,
60-)

from vyper.codegen.expr import Expr
from vyper.codegen.ir_node import Encoding, scope_multi
from vyper.codegen.keccak256_helper import keccak256_helper

            if abi_min_size == abi_size_bound:
                ret.append(["assert", ["eq", abi_min_size, data_len]])
            else:
                # runtime assert: abi_min_size <= data_len <= abi_size_bound
                ret.append(clamp2(abi_min_size, data_len, abi_size_bound, signed=False))

            to_decode = IRnode.from_list(
                data_ptr,
                typ=wrapped_typ,
                location=data.location,
                encoding=Encoding.ABI,
                annotation=f"abi_decode({output_typ})",
 
…[120 chars omitted]…
          # TODO optimization: skip make_setter when we don't need
            # input validation

            output_buf = context.new_internal_variable(wrapped_typ)

            # sanity check buffer size for wrapped output type will not buffer overflow
            assert wrapped_typ.memory_bytes_required == output_typ.memory_bytes_required
            ret.append(make_setter(output_buf, to_decode))

    `start` is the absolute location of the first byte of the buffer and
    `length` is the number of bytes which are valid.  Keeping both `start`
    and `length` around lets us check offsets before adding them to a
    pointer, which avoids arithmetic wrap-around.
    """
    start = IRnode.from_list(start)
    length = IRnode.from_list(length)
    if end is None:
        end = IRnode.from_list(["add", start, length])
    else:
        end = IRnode.from_list(end)

    ir_node.passthrough_metadata[ABI_BUFFER_METADATA] = {
        "start": start,
        "length": length,
        "end": end,
    }
    return ir_node


def _abi_bounds_checks(ptr, size, abi_buffer, what="ABI decode"):
    """
    Return IR assertions which check that [ptr, ptr + size) is inside the
    ABI buffer.  The subtraction form of the check avoids overflow when
    `ptr + size` would wrap around.
    """

    add_ofst,
    calculate_type_for_external_return,
    check_assign,
    check_external_call,
    dummy_node_for_type,
    eval_once_check,
    get_type_for_exact_size,
    make_setter,
    needs_clamp,
    set_abi_buffer,
    unwrap_location,
    wrap_value_for_external_return,
)
from vyper.codegen.ir_node import Encoding, IRnode
from vyper.evm.address_space import MEMORY
from vyper.exceptions import TypeCheckFailure
from vyper.semantics.types import InterfaceT, TupleT
from vyper.semantics.types.function import StateMutability

    gas: IRnode

    min_return_size = abi_return_t.min_size()
    max_return_size = abi_return_t.size_bound()
    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"

    # The valid region is bounded both by the actual amount of returndata
    # and by the static buffer we asked
…[229 chars omitted]…
, max_return_size], "returndatasize", max_return_size],
        typ=UINT256_T,
    )
    set_abi_buffer(buf, buf, returndata_bound)

    unpacker = ["seq"]

    # revert when returndatasize is not in bounds
    # (except when return_override is provided.)
    if not call_kwargs.skip_contract_check:
        assertion = IRnode.from_list(
            ["assert", ["ge", "returndatasize", min_return_size]],

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) -> lis
…[2361 chars omitted]…
data_kwargs)

        calldata_kwargs_ofst = IRnode(
            4, location=CALLDATA, typ=calldata_args_t, encoding=Encoding.ABI
        )
        set_abi_buffer(
            calldata_kwargs_ofst, 4, ["sub", "calldatasize", 4], end="calldatasize"
        )

        # a sequence of statements to strictify kwargs into memory
        ret = ["seq"]

        # ensure calldata is at least of minimum length

        code = """
    @external
    def foo(x: Bytes[160]) -> DynArray[Bytes[32], 2]:
        return _abi_decode(x, DynArray[Bytes[32], 2], unwrap_tuple=False)
        """
>       c = get_contract(code)
            ^^^^^^^^^^^^^^^^^^

tests/functional/builtins/codegen/test_zz_tmp.py:32: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/conftest.py:235: in fn
    return env.deploy_source(source_co
…[5134 chars omitted]…
builtins/functions.py:2504: StructureException
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_abi_decode_bytes_bounds
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 2 passed in 13.05s

        code = """
    @external
    def foo(x: Bytes[160]) -> DynArray[Bytes[32], 2]:
        return _abi_decode(x, DynArray[Bytes[32], 2], unwrap_tuple=False)
        """
>       c = get_contract(code)
            ^^^^^^^^^^^^^^^^^^

tests/functional/builtins/codegen/test_zz_tmp.py:32: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/conftest.py:235: in fn
    return env.deploy_source(source_co
…[5134 chars omitted]…
builtins/functions.py:2504: StructureException
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_abi_decode_bytes_bounds
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 2 passed in 15.47s

tx_failed = <function tx_failed.<locals>.fn at 0x7962d613c680>

    def test_abi_decode_bytes_bounds(get_contract, tx_failed):
        code = """
    @external
    def foo(x: Bytes[224]) -> DynArray[Bytes[32], 2]:
        return _abi_decode(x, DynArray[Bytes[32], 2], unwrap_tuple=False)
        """
        c = get_contract(code)
        # len=2, head0=64, head1=96; both em
…[464 chars omitted]…
tins/codegen/test_zz_tmp.py:40: AssertionError
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_abi_decode_bytes_bounds
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 2 passed in 15.32s

from vyper.utils import ERC5202_PREFIX, method_id


# a very simple log representation for the raw log entries
@dataclass
class LogEntry:
    address: str
    topics: list[str]
    data: tuple[list[bytes], bytes]  # (topic list, non-topic)


# object returned by `last_result` property
@dataclass
class ExecutionResult:
    is_success: bool
    logs: list[LogEntry]
    gas_refunded: int
    gas_used: int


class EvmError(Runti
…[8629 chars omitted]…
loyer, erc20_caller.address, 3)
tests/functional/codegen/calling_convention/test_erc20_abi.py:118:    assert erc20_caller.allowance(env.deployer, erc20_caller.address) == 2
tests/functional/codegen/calling_convention/test_external_contract_calls.py:1143:        c2.foo(env.deployer)
tests/functional/codegen/calling_convention/test_external_contract_calls.py:1395:    env.set_balance(env.deployer, 10000)

…[4330 chars omitted]…
removeprefix("0x"))
tests/unit/compiler/test_bytecode_runtime.py:101:    metadata = _parse_cbor_metadata(initcode)
tests/unit/compiler/test_bytecode_runtime.py:114:    initcode = bytes.fromhex(out["bytecode"].removeprefix("0x"))
tests/unit/compiler/test_bytecode_runtime.py:116:    metadata = _parse_cbor_metadata(initcode)
tests/conftest.py:207:        bytecode, _ = compile_ir.assembly_to_evm(assembly)

# initcode used by create_minimal_proxy_to
def eip1167_initcode(_addr):
    addr = HexBytes(_addr)
    pre = HexBytes("0x602D3D8160093D39F3363d3d373d3d3d363d73")
    post = HexBytes("0x5af43d82803e903d91602b57fd5bf3")
    return HexBytes(pre + (addr + HexBytes(0) * (20 - len(addr))) + post)


# initcode used by CreateCopyOf
def vyper_initcode(runtime_bytecode):
    bytecode_len_hex = hex(len(runtime_bytecode))[2:].rjust(6, "0")
    return HexBytes("0x62" + bytecode_len_hex + "3d81600b3d39f3") + runtime_bytecode


def test_create_minimal_proxy_to_creat
…[1386 chars omitted]…
])
    bytecode, _ = compile_ir.assembly_to_evm(
        compile_ir.compile_to_assembly(ir, optimize=OptimizationLevel.NONE)
    )
    # manually deploy the bytecode
    c = env.deploy(abi=[], bytecode=bytecode)
    blueprint_address = c.address

    d = get_contract(deployer_code, blueprint_address)

    # deploy with code_ofst=0 fine
    d.test(0)

    # deploy with code_ofst=len(blueprint) - 1 fine

    def blob_hashes(self) -> list[bytes]:
        raise NotImplementedError  #
…[6080 chars omitted]…
:16:    env.message_call(address, data=f"0x{sig}{data}")
tests/functional/codegen/features/test_clampers.py:23:    env.message_call(address, data=f"0x{sig}{data}")
tests/functional/codegen/features/test_clampers.py:34:    env.message_call(address, data=f"0x{sig}{data}")
tests/functional/codegen/features/test_constructor.py:87:    env.message_call(c.address, data=method + (1274124).to_bytes(32, "big"))

    extcall Foo(extcall f.bar()).foo()
    return self.counter
    """

    c1 = get_contract(code)
    c2 = get_contract(callee_code)

    assert c1.do_stuff(c2.address) == 1


TEST_ADDR = b"".join(chr(i).encode("utf-8") for i in range(20)).hex()


@pytest.mark.parametrize("typ,val", [("address", TEST_ADDR)])
def test_calldata_clamp(env, get_contract, tx_failed, typ, val):
    code = f"""
@external
def foo(a: {typ}):
    pass
    """
    c1 = get_contract(code)
    sig = method_id(f"foo({typ})").hex()
    encoded = abi.encode(f"({typ})", (val,)).hex()
    data = f"0x{sig}{encoded}"

    # Static size is short by 1 byte
    malformed = data[:-2]
    with tx_failed():
        env.message_cal
…[798 chars omitted]…
2 + 2 (for 0x) = 266)
    valid = data[:266]
    env.message_call(c1.address, data=valid)


def test_make_setter_external_call(get_contract):
    # variant of GH #3503
    code = """
interface A:
   def boo() -> uint256:nonpayable

a: DynArray[uint256, 10]

@external
def foo() -> DynArray[uint256, 10]:
    self.a = [1, 2, extcall A(self).boo(), 4]
    return self.a  # returns [11, 12, 3, 4]

@external

def test_make_setter_external_call2(get_contract):
    # variant of GH #3503
    code = """
interface A:
   def boo(): nonpayable

a: DynArray[uint256, 10]

@external
def foo() -> DynArray[uint256, 10]:
    self.a = [1, 2, self.baz(), 4]
    return self.a # returns [11, 12, 3, 4]


@internal
def baz() -> uint256:
    extcall A(self).boo()
    return 3

@external
def boo():
    self.a = [11, 12, 13, 14, 15, 16]
    self.a = []
    # it should now be impossible to read any of [11, 12, 13, 14, 15, 16]
    """
    c = get_contract(code)

    assert c.foo() == [1, 2, 3, 4]

    def test_external_return_bounds(env, get_contract, tx_failed):
        # returndata: (32, 33, 0) for String[64]. data ends one byte past
        # returndata.
        data = (32).to_bytes(32, "big") + (33).to_bytes(32, "big") + (0).to_bytes(32, "big")
        callee = env.deploy(abi=[], bytecode=_return_fixed(data))
        code = """
    interface Foo:
        def get() -> String[64]: view
    
    @external
    def foo(ad
…[5853 chars omitted]…
/semantics/analysis/local.py:776: CallViolation
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_external_return_bounds
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 3 passed in 14.61s

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,
        gas: int | None =
…[2546 chars omitted]…
m_backends/base_env.py:196: ExecutionReverted
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_external_calldata_bounds
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 4 passed in 16.82s

    def test_external_return_dynarray_extra(env, get_contract, tx_failed):
        code = """
    interface Foo:
        def get() -> DynArray[Bytes[32], 2]: nonpayable
    
    @external
    def foo(addr: address) -> DynArray[Bytes[32], 2]:
        return extcall Foo(addr).get()
        """
        c = get_contract(code)
        # zero-length arrays: wrapped tuple head + array len
        for words in ((32, 0), (0, 0)):
    
…[865 chars omitted]…
egen/test_zz_tmp.py:149: AssertionError
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_external_return_dynarray_extra
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 5 passed in 16.34s

    def test_external_return_dynarray_extra(env, get_contract, tx_failed):
        code = """
    interface Foo:
        def get() -> DynArray[Bytes[32], 2]: nonpayable
    
    @external
    def foo(addr: address) -> DynArray[Bytes[32], 2]:
        return extcall Foo(addr).get()
        """
        c = get_contract(code)
        # zero-length arrays: wrapped tuple head + array len
        for words in ((32, 0), (0, 0)):
    
…[1232 chars omitted]…
degen/test_zz_tmp.py:80: AssertionError
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_external_return_dynarray_extra
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 5 passed in 16.50s

value = 0, gas = None, gas_price = 0, is_modifying = True, blob_hashes = None

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,
        gas: int | None = None,
        gas_price: int = 0,
        is_modifying: bool = T
…[3268 chars omitted]…
ends/base_env.py:196: ExecutionReverted
=========================== short test summary info ============================
FAILED tests/functional/builtins/codegen/test_zz_tmp.py::test_external_return_dynarray_extra
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 5 passed in 16.12s

+
+def get_abi_buffer(ir_node):
+    return ir_node.passthrough_metadata.get(ABI_BUFFER_METADATA)
+
+
+def set_abi_buffer(ir_node, start, length, end=None):
+    """
+    Attach the bounds of the ABI-encoded buffer being decoded to `ir_node`.
+
+    `start` is the absolute location of the first byte of the buffer and
+    `length` is the number of bytes which are valid.  Keeping both `start`
+    and `length` around lets us check offsets before adding
…[8629 chars omitted]…
     head_checks = _abi_bounds_checks(right, head_size, abi_buffer)
+                        copier = _dynarray_make_setter(left, right)
+                        inner = ["seq", count_check, *head_checks, clamp_dyn_array(right), copier]
+                        ret.append(b2.resolve(inner))
+                    ret = b.resolve(ret)
         else:
             ret = _dynarray_make_setter(left, right)

    def erc20(get_contract):
        with open("examples/tokens/ERC20.vy") as f:
>           contract = get_contract(
                f.read(), *[TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS, TOKEN_INITIAL_SUPPLY]
            )

tests/functional/codegen/calling_convention/test_erc20_abi.py:14: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/conftest.py:235: in fn
    return env
…[3412 chars omitted]…
yper/ast/pre_parser.py:43: VersionException
=========================== short test summary info ============================
ERROR tests/functional/codegen/calling_convention/test_erc20_abi.py::test_initial_state
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
123 passed, 1 error in 39.95s

self = <tests.evm_backends.revm_env.RevmEnv object at 0x7211db5ecf50>
to = '0xED4efEAEd8057C619a6D7aACC0459874Eaf3C166', sender = None
data = b'\x05\x9c\xee\xa9\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\x00\x00\x00\x00\x
…[3391 chars omitted]…
===================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 307 passed, 1 warning in 51.54s

........................................................................ [ 85%]
......................................................
…[8629 chars omitted]…
56: Exception
=========================== short test summary info ============================
FAILED tests/functional/codegen/features/test_clampers.py::test_multidimension_dynarray_clamper_passing[0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 833 passed in 74.06s (0:01:14)

........................................................................ [ 85%]
........................................................................ [ 93%]
....................................................                     [100%]
844 passed in 72.27s (0:01:12)

711:        return ["_sym_" + code.args[0].value]
747:        return ["_sym_" + label_name, "JUMPDEST"] + body_asm + pop_scoped_vars
816:                    and is_symbol(assembly[j])
835:    # prune seq
…[3852 chars omitted]…
ets(ctor_mem_size, runtime_codelen):
    # we need two numbers to calculate where the runtime code
    # should be copied to in memory (and making sure we don't
    # trample immutables, which are written to during the ctor
    # code): the memory allocated for the ctor and the length
    # of the runtime code.
    # after the ctor has run but before copying runtime code to
    # memory, the layout is

187:    symbols["return_pc"] = bb.append_instruction("param")
190:    _convert_ir_bb(fn, ir.args[0].args[2], symbols)
196:    fn: IRFunction, ir:
…[1850 chars omitted]…
m.value])
370:    elif ir.value == "symbol":
382:                data = _convert_ir_bb(fn, c, symbols)
395:            _convert_ir_bb(fn, code, symbols)
397:        args = _convert_ir_bb_list(fn, ir.args[1:], symbols)
408:            label = symbols.get("return_pc")
414:        arg_0 = _convert_ir_bb(fn, ir.args[0], symbols)
422:        dst, src_offset, len_ = _convert_ir_bb_list(fn, ir.args, symbols)

            elif isinstance(c.value, bytes):
                data_node.append(c.value)
            elif isinstance(c, IRnode):
                assert c.value == "symbol"
                data_node.extend(
                    _compile_to_assembly(c, withargs, existing_labels, break_dest, height)
                )
            else:
                raise ValueError(f"Invalid data: {type(c)} {c}")

        # intentionally return a sublist.
        return [data_node]

    # jump to a symbol, and push variable # of arguments onto stack
    el
…[1517 chars omitted]…
if ir.value == "data":
        label = IRLabel(ir.args[0].value)
        ctx.append_data("dbname", [label])
        for c in ir.args[1:]:
            if isinstance(c, int):
                assert 0 <= c <= 255, "data with invalid size"
                ctx.append_data("db", [c])  # type: ignore
            elif isinstance(c.value, bytes):
                ctx.append_data("db", [c.value])  # type: ignore

........................................................................ [  0%]
....................................................
…[6779 chars omitted]…
......................................... [  7%]
........................................................................ [  7%]
........................................................................ [  7%]
........................................bash: line 1284:  3895 Killed                  pytest -q tests/functional/codegen/types tests/functional/builtins/codegen -x --disable-warnings --maxfail=1

ardownRaisedWarning: A plugin raised an exception during an old-style hookwrapper teardown.
Plugin: 129444419719856, Hook: pytest_sessionfinish
OSError: cannot send (already closed?)
For more information see https://pluggy.readthedocs.io/en/stable/api_reference.html#pluggy.PluggyTeardownRaisedWarning
  config.hook.pytest_sessionfinish(
bringing up nodes...
bringing up nodes...


no tests ran in 20.56s

test_string_literal.py
test_struct.py

-rw-r--r-- 1 root root  2222 Nov  2 21:45 Makefile
-rw-r--r-- 1 root root  3447 Nov  2 21:45 README.md
-rw-r--r-- 1 root root  2322 Nov  2 21:45 SECURITY.md
-rw-r--r-- 1 root root   190 Nov  2 21:45 codecov.yml
drwxr-xr-x 1 root root  4096 Nov  2 21:45 docs
drwxr-xr-x 1 root root  4096 Nov  2 21:45 examples
drwxr-xr-x 1 root root  4096 Nov  2 21:45 hooks
-rw
…[1415 chars omitted]…
NG.yml
./hooks/build
./LICENSE
./make.cmd
./Makefile
./pyproject.toml
./quicktest.sh
./README.md
./requirements-docs.txt
./SECURITY.md
./setup.cfg
./setup.py
./tests/conftest.py
./tests/utils.py
./tests/__init__.py
./vyper/abi_types.py
./vyper/exceptions.py
./vyper/typing.py
./vyper/utils.py
./vyper/version.py
./vyper/vyper_git_commithash.txt
./vyper/warnings.py
./vyper/__init__.py
./vyper/__main__.py

vyper/ast/nodes.pyi
vyper/ast/parse.py
vyper/ast/pre_parser.py
vyper/ast/utils.py
vyper/ast/validation.py
vyper/builtins/__init__.py
vyper/builtins/_convert.py
vyper/builtins/_signatures.py
vyper/builtins/_utils.py
vyper/builtins/functions.py
vyper/builtins/interfaces/IERC165.vyi
vyper/builtins/interfaces/IERC20.vyi
vyper/builtins/interfaces/IERC20Detailed.vyi
vyper/builtins/interfaces/IERC4626.vyi
vyper/builtins/interfaces/IERC721.vyi
vyper/cli/__init__.py
vyper/cli/compile_archive.py
vyper/cli/vyper_compile.py
vyper/cli/vyper_ir.py
vyper/cli/vyper_json.py
vyper/codegen/__init__.py
vyper/codegen/abi_encoder.py
vyper/codegen/arithmetic.py
…[4162 chars omitted]…
onal/syntax/test_external_calls.py
tests/functional/syntax/test_functions_call.py
tests/functional/syntax/test_raw_call.py
tests/unit/abi_types/test_invalid_abi_types.py
tests/unit/compiler/ir/test_calldatacopy.py
tests/unit/compiler/test_abi.py
tests/unit/semantics/analysis/test_array_index.py
tests/unit/semantics/analysis/test_cyclic_function_calls.py
tests/unit/semantics/types/test_type_from_abi.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 
…[8629 chars omitted]…
et_contract):
    array_accessor = """
@external
def test_array(x: int128, y: int128, z: int128, w: int128) -> int128:
    a: DynArray[int128, 4] = [0, 0, 0, 0]
    a[0] = x
    a[1] = y
    a[2] = z
    a[3] = w
    return a[0] * 1000 + a[1] * 100 + a[2] * 10 + a[3]
    """

    c = get_contract(array_accessor)
    assert c.test_array(2, 7, 1, 8) == 2718
    print("Passed basic array accessor test")

43:        return self.static_size() + self.dynamic_size_bound()
45:    def min_size(self):
46:        return self.static_size() + self.min_dynamic_size()
49:        if not self.is_dynamic():
69:class ABI_GIntM(ABIType):
77:    def is_dynamic(self):
80:    def static_size(self):
113:class ABI_BytesM(ABIType):
120:    def is_dynamic(self):
123:    def static_size(self):
144:class ABI_StaticArray(ABIType):
152:    def is_dynamic(self):
153:        ret
…[357 chars omitted]…
y(ABIType):
213:    def is_dynamic(self):
216:    def static_size(self):
220:        subtyp_size = self.subtyp.embedded_static_size() + self.subtyp.embedded_dynamic_size_bound()
235:class ABI_Tuple(ABIType):
239:    def is_dynamic(self):
240:        return any([t.is_dynamic() for t in self.subtyps])
242:    def static_size(self):
243:        return sum([t.embedded_static_size() for t in self.subtyps])

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 
…[8629 chars omitted]…
maller than expected output
    ),
    (
        """
@external
def foo(x: Bytes[32]):
    _abi_decode(x)
    """,
        ArgumentException,  # Output types arg is missing
    ),
]


@pytest.mark.parametrize("bad_code,exception", FAIL_LIST)
def test_abi_decode_length_mismatch(get_contract, assert_compile_failed, bad_code, exception):
    assert_compile_failed(lambda: get_contract(bad_code), exception)

   242	        # performance: if the subtype is dynamic, there might be a lot
   243	        # of unused space inside of each element. for instance
   244	        # DynArray[DynArray[uint256, 100], 5] where all the child
   245	        # arrays are empty - for this case, we recursively call
   246	        # into make_setter instead of straight
…[8630 chars omitted]…
ontract_2 = """
interface Foo:
    def foo() -> uint8: view

@external
def bar(arg1: address) -> uint8:
    return staticcall Foo(arg1).foo()
"""

    c2 = get_contract(contract_2)
    with tx_failed():
        c2.bar(c.address)


@pytest.mark.parametrize("a,b", [(8, 8), (8, 256), (256, 8), (256, 256)])
@pytest.mark.parametrize("actual", [8, 256])
def test_tuple_with_uint8(get_contract, a, b, actual):

   372	
   373	    return IRnode.from_list(LOAD(arg), typ=typ)
   374	
   375	
   376	# get the number of elements at runtime
   377	def get_dyn_array_count(arg):
   378	    assert isinstance(arg.typ, DArrayT)
   379	
   380	    typ = UINT256_T
   381	
   382	    if arg.value == "multi":
   383	        return IRnode.from_list(len(arg.args), typ=typ)
   384	
   385	    if arg.value == "~empty":
   386	        # empty(DynArray[...])
   38
…[8630 chars omitted]…
de(4, location=CALLDATA, typ=base_args_t, encoding=Encoding.ABI)
vyper/codegen/function_definitions/external_function.py:36:        if needs_clamp(arg.typ, Encoding.ABI):
vyper/codegen/function_definitions/external_function.py:52:                encoding=Encoding.ABI,
vyper/codegen/function_definitions/external_function.py:79:            4, location=CALLDATA, typ=calldata_args_t, encoding=Encoding.ABI

        index = attrs.index(key)
        annotation = key
    else:
        # TupleT
        assert isinstance(key, int)
        subtype = typ.member_types[key]
        attrs = list(typ.tuple_keys())
        index = key
        annotation = None

    # generated by empty() + make_setter
    if parent.value == "~empty":
        return IRnode.from_list("~empty", typ=subtype)

    if parent.value == "multi":
        assert parent.encoding != Encoding.ABI, "no abi-encoded literals"
        return parent.args[index]

    ofst = 0  # offset from parent start

    if parent.encoding == Enc
…[8629 chars omitted]…
(i, dst.location.word_scale))
        src_i = add_ofst(src, _mul(i, src.location.word_scale))

        copy_one_word = STORE(dst_i, LOAD(src_i))

        main_loop = ["repeat", i, 0, n, n_bound, copy_one_word]

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


# get the number of bytes at runtime
def get_bytearray_length(arg):

                # Dynamic gas cost: calldatacopy
                elif self.value.upper() in ("CALLDATACOPY", "CODECOPY", "EXTCODECOPY"):
                    size = 34000
                    size_arg_index = 3
…[8629 chars omitted]…
    return [self.value] + [a.to_list() for a in self.args]

    def __eq__(self, other):
        return (
            self.value == other.value
            and self.args == other.args
            and self.typ == other.typ
            and self.location == other.location
            and self.mutable == other.mutable
            and self.add_gas_estimate == other.add_gas_estimate
        )

    @property

                self.valency = 0
                assert len(self.args) == 3, f"`deploy` should have three args {self}"
                self._gas = NullAttractor()  # unknown
            # Stack variables
            else:
                self.valency = 1
                self._gas = 3
        else:  # pragma: nocover
            raise CompilerPanic(f"Invalid value for IR 
…[4219 chars omitted]…
    encoding=encoding,
                error_msg=error_msg,
                is_self_call=is_self_call,
                passthrough_metadata=passthrough_metadata,
            )
vyper/codegen/core.py:1088:def clamp_bytestring(ir_node):
vyper/codegen/core.py:1096:def clamp_dyn_array(ir_node):
vyper/codegen/core.py:1188:def clamp(op, arg, bound):
vyper/codegen/core.py:1208:def clamp2(lo, arg, hi, signed):

  1072	
  1073	
  1074	# convenience rewrites for shr/sar/shl
  1075	def shr(bits, x):
  1076	    return ["shr", bits, x]
  1077	
  1078	
  1079	# convenience rewrites for shr/sar/shl
  1080	def shl(bits, x):
  1081	    return ["shl", bits, x]
  1082	
  1083	
  1084	def sar(bi
…[7426 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)

        else:
            self.memory_allocator.deallocate_memory(var.pos, var.size)

        del self.vars[var.name]

    def _new_variable(
        self,
        name: str,
        typ: VyperType,
        is_internal: bool,
        is_mutable: bool = True,
        internal_function=False,
    ) -> IRnode:
        size = typ.memory_bytes_required

        ofst = self.memory_allocator.
…[1924 chars omitted]…
memory allocation

        Returns
        -------
        int
            Memory offset for the variable
        """
        # internal variable names begin with a number sign so there is no chance for collision
        name = self.fresh_varname("#internal")

        return self._new_variable(name, typ, is_internal=True)
./vyper/codegen/expr.py:694:                return append_dyn_array(darray, arg)

count,
vyper/codegen/stmt.py:278:            array_len = get_dyn_array_count(iter_list)
vyper/semantics/types/subscriptable.py:184:    # TODO rename to `memory_bytes_required`
vyper/semantics/types/subscriptable.py:223:class DArrayT(_SequenceT):
vyper/semantics/types/subscriptable.py:270:    # TODO rename me to memory_bytes_required
vyper/semantics/types/bytestrings.py:9:class _BytestringT(VyperType):

        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
…[8630 chars omitted]…
._min_length > min_length:
   103	            raise CompilerPanic("Cannot reduce the min_length of ArrayValueType")
   104	        self._min_length = min_length
   105	
   106	    def compare_type(self, other):
   107	        if not super().compare_type(other):
   108	            return False
   109	
   110	        # CMC 2022-03-18 TODO this method should be refactored so it does not have side effects

336:    # "mstore" to the data section of (to-be-deployed) runtime code
343:        o.extend(_data_ofst_of("_mem_deploy_end", loc, height + 1))
348:
…[8045 chars omitted]…
n_t = func_ast._metadata["func_type"]
        if fn_t.is_internal:
            to_visit.update(fn_t.reachable_internal_functions)
            to_visit.add(fn_t)

    for fn_t in to_visit:
        if fn_t._ir_info is None:
            id_generator.ensure_id(fn_t)
            _ = _ir_for_internal_function(fn_t.ast_def, module_t, False)

    return IRnode.from_list(deploy_code), IRnode.from_list(runtime)

@pytest.fixture(scope="module")
def account_keys():
    random = Random(b"vyper")
    return [PrivateKey(random.randbytes(32)) for _ in range(10)]


@pytest.fixture(scope="module")
def env(gas_limit, evm_version, evm_backend, tracing, account_keys) -> BaseEnv:
    return evm_backend(
        gas_limit=gas_limit,
        tracing=tracing,
        block_number=1,
        evm_version=evm_version,
        account_keys=account_keys,
    )


@pytest.fixture
def get_contract_from_ir(env, optimize):
    def ir_compiler(ir, *args, **kwargs):
        ir = IRnode.from_list(ir)
        if kwargs.pop("optimize", optimize) != OptimizationLevel
…[8629 chars omitted]…
str):
        """
        :param abi: the ABI entry for this function
        :param contract_name: the name of the contract this function belongs to
        """
        self._abi = abi
        self._contract_name = contract_name
        self._function_visibility = FunctionVisibility.EXTERNAL
        self._mutability = StateMutability.from_abi(abi)
        self.contract: Optional["ABIContract"] = None

        # general case, copy word-for-word
        # pseudocode for our approach (memory-storage as example):
        # for i in range(len, bound=MAX_LEN):
        #   sstore(_dst + i, mload(src + i * 32))
        i = IRnode.from_list(_freshname("copy_bytes_ix"), typ=UINT256_T)

        # optimized form of (div (ceil32 len) 32)
        n = ["
…[4747 chars omitted]…
_attrs())

    def __eq__(self, other):
        if self is other:
            return True
        return (
            type(self) is type(other) and self._get_equality_attrs() == other._get_equality_attrs()
        )

    def __lt__(self, other):
        return self.abi_type.selector_name() < other.abi_type.selector_name()

    # return a dict suitable for serializing in the AST
    def to_dict(self):

    # code): the memory allocated for the ctor and the length
    # of the runtime code.
    # after the ctor has run but before copying runtime code to
    # memory, the layout is
    # <ctor memory variables> ... | data section
    # and after copying runtime code to memory (immediately before
    # returning the runtime code):
    # <runtime code>          ... | data section
    # since the ctor memory variables and runtime code overlap,
    # we start allocating the data section from
    # `max
…[8629 chars omitted]…
mar, start, explicit_strategies):
tests/functional/syntax/exceptions/test_call_violation.py:32:def __init__():
tests/functional/syntax/exceptions/test_constancy_exception.py:116:def __init__():
tests/functional/syntax/exceptions/test_function_declaration_exception.py:28:def __init__(a: int128 = 12):
tests/functional/syntax/exceptions/test_function_declaration_exception.py:33:def __init__() -> uint256:

    out_of_gas_error = "OutOfGas"

    def __init__(
        self,
        gas_limit: int,
        account_keys: list[PrivateKey],
        tracing: bool,
        block_number: int,
        evm_version: str,
    ) -> None:
        super().__init__(gas_limit, account_keys)
        self._evm = EVM(
            gas_limit=gas_limit,
            tracing=tracing,
            spec_id=evm_version,
            env=Env(block=BlockEnv(number=block_number)),
        )

    @contextmanager
    def anchor(self):
        snapshot_id = self._evm.snapshot()
        block = BlockEnv(number=self._evm.env.b
…[8629 chars omitted]…
00000"


@contextlib.contextmanager
def working_directory(directory):
    tmp = os.getcwd()
    try:
        os.chdir(directory)
        yield
    finally:
        os.chdir(tmp)


def parse_and_fold(source_code):
    ast = vy_ast.parse_to_ast(source_code)
    constant_fold(ast)
    return ast


def decimal_to_int(*args):
    s = decimal.Decimal(*args)
    return round_towards_zero(s / DECIMAL_EPSILON)

from vyper.compiler.settings import Settings, anchor_settings, get_global_settings
from vyper.typing import OutputFormats, StorageLayout

OUTPUT_FORMATS = {
    # requires vyper_module
    "ast_dict": output.build_ast_dict,
    # requires annotated_vyper_module
    "annotated_ast_dict": output.build_annotated_ast_dict,
    "layout": output.build_layout_output,
    "devdoc": output.b
…[6992 chars omitted]…
ImplementedError

    @property
    def timestamp(self) -> int | None:
        raise NotImplementedError  # must be implemented by subclasses

    @timestamp.setter
    def timestamp(self, value: int):
        raise NotImplementedError  # must be implemented by subclasses

    @property
    def last_result(self) -> ExecutionResult:
        raise NotImplementedError  # must be implemented by subclasses

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

…[8630 chars omitted]…
20-   220	        node: Union[vy_ast.UnaryOp, vy_ast.BinOp, vy_ast.AugAssign, vy_ast.Compare, vy_ast.BoolOp],
221-   221	    ) -> None:
222-   222	        raise InvalidOperation(f"Cannot perform {node.op.description} on {self}", node.op)
223-   223	
224-   224	    def validate_comparator(self, node: vy_ast.Compare) -> None:
225-   225	        """
226-   226	        Validate a comparator for this type.

   157	    """
   158	
   159	    typeclass = "static_array"
   160	
   161	    _id = "$SArray"
   162	
   163	    def __init__(self, value_type: VyperType, length: int) -> None:
   164	        super().__init__(value_type, length)
   165	
   166	    def __repr__(self):
   167	        return f"{self.value_type}[{self.length}]"
   168	
   169	    @property
   170	    def _as_array(self):
   171	        # a static array is arrayable if its value_type is arrayble.
   172	        return
…[8628 chars omitted]…
 context):
  1022	    """Ensure a variable is in memory. This is useful for functions
  1023	    which expect to operate on memory variables.
  1024	    """
  1025	    if ir_var.location == MEMORY:
  1026	        return ir_var
  1027	
  1028	    typ = ir_var.typ
  1029	    buf = IRnode.from_list(context.new_internal_variable(typ), typ=typ, location=MEMORY)
  1030	    do_copy = make_setter(buf, ir_var)

    Tuple type definition.

    This class is used to represent multiple return values from functions.
    """

    typeclass = "tuple"

    _equality_attrs = ("members",)
    _id = "$Tuple"

    # note: docs say that tuples are not instantiable but they
    # are in fact instantiable and the codegen works. if we
    # wanted to be stricter in the typechecker, we could
    # add _invalid_locations = everything but UNSET and RETURN_VALUE.
    # (we would need to add a DataLocation.RETURN_VALUE in order for
    # tuples to be instantiable as return valu
…[4578 chars omitted]…
ncalldatasize = max(f.min_calldatasize for f in entry_points.values())
257:            func_metadata_int = entry_point.min_calldatasize | int(
279:def _selector_section_sparse(external_functions, module_t):
337:            expected_calldatasize = entry_point.min_calldatasize
384:def _selector_section_linear(external_functions, module_t):
397:        expected_calldatasize = entry_point.min_calldatasize

            ofst = _compile_to_assembly(ofst, withargs, existing_labels, break_dest, height_)
            return ofst + [sym, "ADD"]

    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 isins
…[23 chars omitted]…
set):
        raise CompilerPanic(f"must be set(), but got {type(existing_labels)}")

    # Opcodes
    if isinstance(code.value, str) and code.value.upper() in get_opcodes():
        o = []
        for i, c in enumerate(code.args[::-1]):
            o.extend(_compile_to_assembly(c, withargs, existing_labels, break_dest, height + i))
        o.append(code.value.upper())
        return o

    # Numbers

    # set a symbol as a location.
    elif code.value == "label":
        label_name = code.args[0].value
        assert isinstance(label_name, str)

        if label_name in existing_labels:
            raise Exception(f"Label with name {label_name} already exists!")
        else:
            existing_labels.add(label_name)

        if code.args[1].value != "var_list":
            raise CodegenPanic("2nd arg to label must be var_li
…[3836 chars omitted]…
method_id_check]
368-            handle_bucket.append(["if", method_id_check, dispatch])
369-
370-        # close out the bucket with a goto fallback so we don't keep searching
371-        handle_bucket.append(["goto", "fallback"])
372-
373-        ret.append(handle_bucket)
374-
375-    ret = ["seq", ["with", "_calldata_method_id", shr(224, ["calldataload", 0]), ret]]
376-
377-    return ret
378-
379-

        """Merge positional and keyword arguments into a single list."""
        if len(kwargs) + len(args) != self.argument_count:
            raise TypeError(
                "invocation failed due to improper number of arguments to"
                f" `{repr(self)}` (expected {self.argument_count} "
                f"arguments, got {len(args)} args and {len(kwargs)} kwargs)"
            )
        try:
            kwarg_inputs = self._abi["
…[4555 chars omitted]…
get_code(address)
        if not self._deployed_bytecode:
            warn(f"Requested {self} but there is no bytecode at that address!", stacklevel=2)

        overloads = defaultdict(list)
        for f in functions:
            overloads[f.name].append(f)

        for name, group in overloads.items():
            setattr(self, name, ABIOverload.create(group, self))

        self._address = address

    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
…[859 chars omitted]…

            stomp_return_buffer.append(_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

60:    "CODESIZE": (0x38, 0, 1, 2),
63:    "EXTCODESIZE": (0x3B, 1, 1, 2600),

665:        # ceil32(x) = floor32(x + 31) == (x + 31) & (~31)

        )

    # e.g. 95 -> 96, 96 -> 96, 97 -> 128
    elif code.value == "ceil32":
        # floor32(x) = x - x % 32 == x & 0b11..100000 == x & (~31)
        # ceil32(x) = floor32(x + 31) == (x + 31) & (~31)
        x = code.args[0]
        return _compile_to_assembly(
            IRnode.from_list(["and", ["add", x, 31], ["not", 31]]),
            withargs,
            existing_labels,
            break_dest,
            height,
        )

    elif code.value == "data":
        if c in "0123456789":
            o += c
        else:
            o += c.upper() if (v & (2 ** (255 - 4 * i))) else c.lower()
    return "0x" + o


# Returns lowest multiple of 32 >= the input
def ceil32(x):
    return x if x % 32 == 0 else x + 32 - (x % 32)


# Calculates amount of gas needed for memory expansion
def calc_mem_gas(memsize):
    return (memsize // 32) * 3 + (memsize // 32) ** 2 // 512

vyper/codegen/core.py:377:def get_dyn_array_count(arg):

        changed_flags, argz = zip(*res)  # type: ignore
        args_changed = any(changed_flags)
        argz = list(argz)

    value = node.value
    typ = node.typ
    location = node.location
    ast_source = node.ast_source
    error_msg = node.error_msg
    annotation = node.annotation
    add_gas_estimate = node.add_gas_estimate
    is_self_call = node.is_self_call
    passthrough_metadata = node.passthrough_metadata

    changed = False

    # in general, we cannot enforce the symbols check. for instance,
    # the dead branch eliminator will almost always trip 
…[2655 chars omitted]…
_global_symbols:
            alloca = ir.passthrough_metadata["alloca"]
            ptr = fn.get_basic_block().append_instruction("store", alloca.offset)
            _global_symbols[ir.value] = ptr

        return _global_symbols.get(ir.value) or symbols.get(ir.value)
    elif ir.is_literal:
        return IRLiteral(ir.value)
    else:
        raise Exception(f"Unknown IR node: {ir}")

    return None

  File "/repo/vyper/compiler/__init__.py", line 126, in compile_from_file_input
    ret[output_format] = formatter(compiler_data)
                         ^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/vyper/compiler/output.py", line 231, in build_abi_output
    _ = 
…[2744 chars omitted]…
ctions.py", line 2503, in build_IR
    raise StructureException(
vyper.exceptions.StructureException: Mismatch between size of input and size of decoded types. length of ABI-encoded (String[64]) must be equal to or greater than 128

  function "decode", line 4:23 
       3 def decode(x: Bytes[96]) -> String[64]:
  ---> 4     return _abi_decode(x, String[64])
  ------------------------------^
       5

        o.extend(_compile_to_assembly(code.args[1], withargs, existing_labels, break_dest, height))
        old = withargs.get(code.args[0].value, None)
        withargs[code.args[0].value] = height
        o.extend(
            _compile_to_assembly(code.args[2], withargs, existing_labels, break_dest, height + 1)
        )
        if code.args[2].valency:
            o.extend(["SWAP1", "POP"])
        else:
            o.extend(["POP"])
        if old is not None:
            with
…[6562 chars omitted]…
 ) -> Union["ABIOverload", ABIFunction]:
236-        """
237-        Create an ABIOverload if there are multiple functions, otherwise
238-        return the single function.
239-        :param functions: a list of functions with the same name
240-        :param contract: the ABIContract that these functions belong to
241-        """
242-        for f in functions:
243-            f.contract = contract

    data_section_lengths = []
    immutables_len = None

    # go through the code, resolving symbolic locations
    # (i.e. JUMPDEST locations) to actual code locations
    for i, item in enumerate(assembly):
        note_line_num(line_number_map, pc, item)
        if item == "DEBUG":
            continue  # skip debug

        # update pc_jump_map
        if item == "JUMP":

…[3455 chars omitted]…
          continue  # skippable opcodes

        elif is_symbol(item):
            # push a symbol to stack
            if not is_symbol_map_indicator(assembly[i + 1]):
                bytecode, _ = assembly_to_evm(PUSH_N(symbol_map[item], n=SYMBOL_SIZE))
vyper/codegen/function_definitions/external_function.py:29:        base_args_ofst = IRnode(0, location=DATA, typ=base_args_t, encoding=Encoding.ABI)

937-    ret = ["seq"]
938-
939-    if isinstance(left.typ, SArrayT):
940-        n_items = right.typ.count
941-        keys = [IRnode.from_list(i, typ=UINT256_T) for i in range(n_items)]
942-
943-    else:
944-        assert is_tuple_like(left.typ)
945-        keys = left.typ.tuple_keys()
946-
947-    if left.is_pointer and right.is_pointer and right.encoding == Encoding.VYPER:
948-        # both left and right are pointers, see if we want to batch copy
949-        # instead of unrolling the loop.
950-        assert left.encoding == Encoding.VYPER
951-        len_ = left.typ.memory_bytes_required
952-
953-        # special logic for identity precompile (pre-cancun) in the else branch
954-        mem2mem = left.location == right.location == MEMORY
955-
128:    def from_annotation(cls, node: vy_ast.VyperNode) -> "_BytestringT":

vyper/builtins/_convert.py:438:    return IRnode.from_list(ret, typ=out_typ, location=arg.location, encoding=arg.encoding)
vyper/codegen/core.py:442:    return IRnode.from_list(ret, location=ptr.location, encoding=ptr.encoding)

721-
722-
723-def set_type_for_external_return(ir_val):
724-    # used for RHS promotion
725-    ir_val.typ = calculate_type_for_external_return(ir_val.typ)
726-
727-
728-# return a dummy IRnode with the given type
729-def dummy_node_for_type(typ):
730-    return IRnode("fake_node", typ=typ)
731-
732-
733-def _check_assign_bytes(left, right):
734-    if right.typ.maxlen > left.typ.maxlen:  # pragma: nocover
735-        raise TypeMismatch(f"Cannot cast from {right.typ} to {left.typ}")
736-
737-    # stricter check for zer
…[244 chars omitted]…
right.typ}) to {left.typ}")
741-
742-
743-def _check_assign_list(left, right):
744-    def FAIL():  # pragma: no cover
vyper/codegen/abi_encoder.py:127:    return not typ.abi_type.is_dynamic()
vyper/codegen/core.py:237:        should_loop = src.encoding == Encoding.ABI and src.typ.value_type.abi_type.is_dynamic()
vyper/codegen/core.py:250:        should_loop |= src.typ.value_type.abi_type.is_dynamic()

87-    # add a goto to make the function entry look like other functions
88-    # (for zksync interpreter)
89-    ret.append(["goto", func_t._ir_info.external_function_base_entry_label])
90-    ret.append(func_ir.common_ir)
91-
92-    return IRnode.from_list(ret)
93-
94-
95-def _ir_for_internal_function(func_ast, *args, **kwargs):
96-    return generate_ir_for_internal_function(func_ast,
…[4084 chars omitted]…
_t)
133-
134-    # generate the label so the jumptable works
135-    for abi_sig, entry_point in entry_points.items():
136-        label = label_for_entry_point(abi_sig, entry_point)
137-        ir_node = ["label", label, ["var_list"], entry_point.ir_node]
138-        function_irs.append(IRnode.from_list(ir_node))
139-
vyper/codegen/module.py:75:def _ir_for_fallback_or_ctor(func_ast, *args, **kwargs):

   432	    default_function = next((f for f in runtime_functions if _is_fallback(f)), None)
   433	
   434	    internal_functions_ir: list[IRnode] = []
   435	
308:        o.extend(PUSH(MemoryPositions.FREE_VAR_SPACE) + ["CODECOPY"])
323:        o.extend(["CODECOPY"])
522:        o.extend(["_sym_subcode_size", runtime_begin, "_mem_deploy_start", "CODECOPY"])

                 annotation=f"abi_decode({output_typ})",
             )
             to_decode.encoding = Encoding.ABI
+            # All ABI pointer arithmetic below is relative to this exact
+            # runtime payload, not
…[8628 chars omitted]…
nstance(body, IRnode):
             return IRnode.from_list(
-                ret, typ=body.typ, location=body.location, encoding=body.encoding
+                ret,
+                typ=body.typ,
+                location=body.location,
+                encoding=body.encoding,
+                passthrough_metadata=body.passthrough_metadata.copy(),
             )
         else:
             return ret

              [goto, external 0 decode(Bytes[128])_common],
              # Line 3
              [seq,
                [label,
                  external 0 decode(Bytes[128])_common,
                  var_list,
                  [seq,
                    [with,
                      bs_ptr,
                      [seq,
                        [assert,
                          [ge,
                            [add,
                              4,
                              [seq,
                                [assert, [and, [gt, call
…[7484 chars omitted]…
 [add, 32, [mload, dst]]]]]]]],
                            dyn_ofst]]],
                      pass]]],
                [label,
                  external 0 decode(Bytes[128])_cleanup,
                  [var_list, ret_ofst, ret_len],
                  [return, ret_ofst, ret_len]]]]]],
        [goto, fallback]]]],
  [goto, fallback],
  [label, fallback, var_list, /* Default function */ [revert, 0, 0]]]

              [goto, external 0 decode(Bytes[128])_common],
              # Line 3
              [seq,
                [label,
                  external 0 decode(Bytes[128])_common,
                  var_list,
                  [seq,
                    [with,
                      bs_ptr,
                      [seq,
                        [assert,
                          [ge,
                            [add,
                              4,
                              [seq,
                                [assert, [and, [gt, call
…[7484 chars omitted]…
 [add, 32, [mload, dst]]]]]]]],
                            dyn_ofst]]],
                      pass]]],
                [label,
                  external 0 decode(Bytes[128])_cleanup,
                  [var_list, ret_ofst, ret_len],
                  [return, ret_ofst, ret_len]]]]]],
        [goto, fallback]]]],
  [goto, fallback],
  [label, fallback, var_list, /* Default function */ [revert, 0, 0]]]

    with src.cache_when_complex("src") as (b1, src):
        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
…[1689 chars omitted]…
BYTES32_T)
920-
921-    raise CompilerPanic("unreachable")  # pragma: nocover
922-
923-
924-# Create an x=y statement, where the types may be compound
925-def make_setter(left, right):
926-    check_assign(left, right)
927-
928-    # For types which occupy just one word we can use single load/store
929-    if left.typ._is_prim_word:
930-        enc = right.encoding  # unwrap_location butchers encoding

  1140	        raise CompilerPanic(f"{t} passed to clamp_bytestring")
  1141	    ret = ["assert", ["le", get_bytearray_length(ir_node), t.maxlen]]
  1142	    return IRnode.from_list(ret, error_msg=f"{ir_node.typ} bounds check")
  1143	
  1144	
  1145	def clamp_dyn_array(ir_node):
  1146	    t = ir_node.typ
  1147	    assert isinstance(t, DArrayT)
  1148	    ret = ["assert", ["le", get_dyn_array_count(ir_node), t.count]]
  1149	    return IRnode.from_list(ret, error_msg=f"{ir_node.typ} bounds check")
  1150	
  1151	
  1152	# clampers for basetype
  1153	def clamp
…[313 chars omitted]…
bits = len(t._flag_members)
  1163	        # assert x >> bits == 0
  1164	        ret = int_clamp(ir_node, bits, signed=False)
  1165	
  1166	    elif isinstance(t, (IntegerT, DecimalT)):
  1167	        if t.bits == 256:
  1168	            ret = ir_node
  1169	        else:
  1170	            ret = int_clamp(ir_node, t.bits, signed=t.is_signed)
vyper/codegen/core.py:1137:def clamp_bytestring(ir_node):

    return IRnode.from_list(LOAD(arg), typ=typ)


# get the number of elements at runtime
def get_dyn_array_count(arg):
    assert isinstance(arg.typ, DArrayT)

    typ = UINT256_T

    if arg.value == "multi":
        return IRnode.from_list(len(arg.args), typ=typ)

    if arg.value == "~empty":
        # empty(DynArray[...])
        return IRnode.from_list(0, typ=typ)

    return IRnode.from_list(LOAD(arg), typ=typ)


def append_dyn_array(darray_node, elem_node, context):
    assert isinstance(darray_node.typ, DArra
…[5072 chars omitted]…
ring")
    ret = ["assert", ["le", get_bytearray_length(ir_node), t.maxlen]]
    return IRnode.from_list(ret, error_msg=f"{ir_node.typ} bounds check")


def clamp_dyn_array(ir_node):
    t = ir_node.typ
    assert isinstance(t, DArrayT)
    ret = ["assert", ["le", get_dyn_array_count(ir_node), t.count]]
    return IRnode.from_list(ret, error_msg=f"{ir_node.typ} bounds check")


# clampers for basetype

750-    # and `(bytes,)` is returned as abi-encoded ((bytes,),)
751-    # In general `-> X` gets returned as (X,)
752-    # including structs. MyStruct is returned as abi-encoded (MyStruct,).
753-    # (Sorry this is so confusing. I didn't make these rules.)
754-
755-    return not (isinstance(typ, TupleT) and typ.length > 1)
756-
757-
758-def calculate_type_for_external_return(typ):
        if self._length:

# get the number of elements at runtime$
def get_dyn_array_count(arg):$
    assert isinstance(arg.typ, DArrayT)$
$
    typ = UINT256_T$
$
    if arg.value == "multi":$
        return IRnode.from_list(len(arg.args), typ=typ)$
$
    if arg.value == "~empty":$
        # empty(DynArray[...])$
        return IRnode.from_list(0, typ=typ)$
$
    return IRnode.from_list(LOAD(arg), typ=typ)$
$
$
def append_dyn_array(darray_node, elem_node, context):$
    assert isinstance(darray_node.typ, DArrayT)$
$
    assert darray_node.typ.count > 0, "jerk boy u r out"$
$
   
…[1577 chars omitted]…
i, arg in enumerate(func_t.positional_args):
        arg_ir = get_element_ptr(base_args_ofst, i)

        if needs_clamp(arg.typ, Encoding.ABI):
            # allocate a memory slot for it and copy
            dst = context.new_variable(arg.name, arg.typ, is_mutable=False)

            copy_arg = make_setter(dst, arg_ir)
            copy_arg.ast_source = arg.ast_source
            ret.append(copy_arg)

[gw5] linux -- Python 3.12.13 /usr/local/bin/python

self = <tests.evm_backends.revm_env.RevmEnv object at 0x7554fc293ec0>
to = '0xED4efEAEd8057C619a6D7aACC045
…[3592 chars omitted]…
=========== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 483 passed, 1 warning in 97.19s (0:01:37)

  2502	    # Static size is exact
  2503	    env.message_call(c1.address, data=data)
  2504	
  2505	    # Static size exceeds by 1 byte, ok
  2506	    env.message_call(c1.address, data=data + "ff")
  2507	
  2508	
  2509	@pytest.mark.parametrize("typ,val", [("address", ([TEST_ADDR] * 3, "vyper"))])
  2510	def test_dynamic_calldata_clamp(env, get_contract, tx_failed, typ, val):
  2511	    code = f"""
  2512	@external
  2513	def foo(a: DynArray[{typ}, 3], b: String[5]):
  2514	    pass
  2515	    """
 
…[1212 chars omitted]…
             |   4 +
 vyper/codegen/core.py                              | 112 ++++++++++++++++++---
 vyper/codegen/expr.py                              |   2 +-
 vyper/codegen/external_call.py                     |   8 ++
 .../function_definitions/external_function.py      |  40 +++++++-
 vyper/codegen/ir_node.py                           |  12 ++-
 6 files changed, 156 insertions(+), 22 deletions(-)

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  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, in accept
    return fn(self, *args, **kwa
…[1053 chars omitted]…
     ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/eth/codecs/abi/encoder.py", line 72, in visit_AddressNode
    raise EncodeError("address", value, "Value is not an instance of type 'str'")
eth.codecs.abi.exceptions.EncodeError: Error encoding b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13' as 'address' - Value is not an instance of type 'str'

    # TODO: it would be nice to merge the implementations of get_bytearray_length and
    # get_dyn_array_count
    if arg.value == "~empty":
        return IRnode.from_list(0, typ=typ)

    length = IRnode.from_list(LOAD(arg), typ=typ)
    if arg.encoding != Encoding.ABI or arg.passthrough_metadata.get("abi_decode_end") is None:
        return length

    # A dynamic bytestring consists of a length word followed by its padded
    # data. Validate the length word before 
…[5320 chars omitted]…
,
                encoding=parent.encoding,
                passthrough_metadata=parent.passthrough_metadata.copy(),
            )
        ofst_ir = child_ptr

    return IRnode.from_list(
        ofst_ir,
        typ=member_t,
        location=parent.location,
        encoding=parent.encoding,
        annotation=f"{parent}{ofst}",
        passthrough_metadata=parent.passthrough_metadata.copy(),
    )

   435	        with old_len.cache_when_complex("old_darray_len") as (b2, old_len):
   436	            before_append = ["seq"]
   437	            assertion = ["assert", ["lt", old_len, darray_node.typ.count]]
   438	            before_append.append(
   439	 
…[2626 chars omitted]…
(),
   491	    )
   492	
   493	
   494	def _abi_bounds_check(ptr, size):
   495	    """Assert that a byte range within an ABI buffer does not exceed its end."""
   496	    end = ptr.passthrough_metadata.get("abi_decode_end")
   497	    if ptr.encoding != Encoding.ABI or end is None:
   498	        return ["pass"]
   499	
   500	    # Use subtraction instead of adding size to ptr so an overflowing end

to = '0xED4efEAEd8057C619a6D7aACC0459874Eaf3C166', sender = None
data = b'\x05\x9c\xee\xa9\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\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13'

…[3305 chars omitted]…
===================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 229 passed, 1 warning in 49.60s

[gw6] linux -- Python 3.12.13 /usr/local/bin/python

self = <tests.evm_backends.revm_env.RevmEnv object at 0x715dcbb781d0>
to = '0xED4efEAEd8057C619a6
…[3601 chars omitted]…
=========== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 492 passed, 1 warning in 90.34s (0:01:30)

tests/functional/syntax/test_raw_call.py:111:def test_raw_call_success(good_code):

        return IRnode.from_list(0, typ=typ)

    length = IRnode.from_list(LOAD(arg), typ=typ)
    if arg.encoding != Encoding.ABI or arg.passthrough_metadata.get("abi_decode_end") is None:
        return length

    # A dynamic bytestring consists of a length word followed by its padded
    # data. Validate the length word before loading the length, then ensure the
    # complete encoded value is inside the input buffer.
    data = add_ofst(arg, 32)
    ret = [
        "seq",
        _abi_bounds_check(arg, 32),
        ["assert", ["
…[7994 chars omitted]…
erride_value = wrap_value_for_external_return(call_kwargs.default_return_value)
        stomp_return_buffer = ["seq"]
        if not call_kwargs.skip_contract_check:
            stomp_return_buffer.append(_extcodesize_check(contract_address))
        stomp_return_buffer.append(make_setter(return_buf, override_value))
        unpacker = ["if", ["eq", "returndatasize", 0], stomp_return_buffer, unpacker]

              [goto, external 0 decode(Bytes[128])_common],
              # Line 3
              [seq,
                [label,
                  external 0 decode(Bytes[128])_common,
                  var_list,
                  [seq,
                    [with,
                      bs_ptr,
                      [seq,
                        [assert,
                          [ge,
                            [add,
                              4,
                              [seq,
                                [assert,
               
…[8629 chars omitted]…
 [add, 32, [mload, dst]]]]]]]],
                            dyn_ofst]]],
                      pass]]],
                [label,
                  external 0 decode(Bytes[128])_cleanup,
                  [var_list, ret_ofst, ret_len],
                  [return, ret_ofst, ret_len]]]]]],
        [goto, fallback]]]],
  [goto, fallback],
  [label, fallback, var_list, /* Default function */ [revert, 0, 0]]]

    encoded = abi.encode(f"({typ})", (val,)).hex()
    data = f"0x{sig}{encoded}"

    # Static size is short by 1 byte
    malformed = data[:-2]
    with tx_failed():
        env.message_call(c1.address, data=malformed)

    # Static size is exact
    env.message_call(c1.address, data=data)

    # Static size exceeds by 1 byte, ok
    env.message_call(c1.address, data=data + "ff")


@pytest.mark.parametrize("typ,val", [("address", ([TEST_ADDR] * 3, "vyper"))])
def test_dynamic_calldata_clamp(env, get_contract, tx_failed, typ, val):
    code = f"""
@external

…[161 chars omitted]…
ncode(f"({typ}[],string)", val).hex()
    data = f"0x{sig}{encoded}"

    # Dynamic size is short by 1 byte
    malformed = data[:264]
    with tx_failed():
        env.message_call(c1.address, data=malformed)

    # Dynamic size is at least minimum (132 bytes * 2 + 2 (for 0x) = 266)
    valid = data[:266]
    env.message_call(c1.address, data=valid)


def test_make_setter_external_call(get_contract):

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,

…[3069 chars omitted]…
erted
=========================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 30 passed in 31.17s

    # Dynamic size is at least minimum (132 bytes * 2 + 2 (for 0x) = 266)
    valid = data[:266]
    env.message_call(c1.address, data=valid)


def test_make_setter_external_call(get_contract):
000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000102030405060708090a0b0c0d0e0f10111213
word pos 64 count 3 last_head 000000000000000000000000000102030405060708090a0b0c0d0e0f10111213 string len 5

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,
        gas: int | None = Non
…[3029 chars omitted]…
xecutionReverted
=========================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed in 13.50s

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,
        gas: int | None = Non
…[3029 chars omitted]…
xecutionReverted
=========================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed in 13.54s

    def message_call(
        self,
        to: str,
        sender: str | None = None,
        data: bytes | str = b"",
        value: int = 0,
        gas: int | None = Non
…[3029 chars omitted]…
xecutionReverted
=========================== short test summary info ============================
FAILED tests/functional/codegen/calling_convention/test_external_contract_calls.py::test_dynamic_calldata_clamp[address-val0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed in 13.28s