From 2c0fc971079695430a0493294b2f33e9d20a7e01 Mon Sep 17 00:00:00 2001 From: Guillaume Claret Date: Mon, 6 Jan 2025 14:43:02 +0100 Subject: [PATCH] more wip --- .github/workflows/rust.yml | 18 +- .gitignore | 3 + CoqOfRust/revm/of_json/common.v | 9 + CoqOfRust/revm/of_json/context.py | 14 + .../revm/of_json/context/interface/host.v | 26 + CoqOfRust/revm/of_json/of_json.py | 248 + CoqOfRust/revm/of_json/specification.py | 14 + .../revm/of_json/specification/hardfork.v | 29 + .../revm/translations/context/block.json | 5616 ++ CoqOfRust/revm/translations/context/block.v | 1055 + CoqOfRust/revm/translations/context/cfg.json | 3620 + CoqOfRust/revm/translations/context/cfg.v | 680 + .../revm/translations/context/context.json | 26582 ++++++ CoqOfRust/revm/translations/context/context.v | 5202 ++ .../translations/context/interface/block.json | 9583 ++ .../translations/context/interface/block.v | 1404 + .../context/interface/block/blob.json | 3452 + .../context/interface/block/blob.v | 547 + .../translations/context/interface/cfg.json | 11121 +++ .../revm/translations/context/interface/cfg.v | 1792 + .../context/interface/errors.json | 601 + .../translations/context/interface/errors.v | 88 + .../translations/context/interface/host.json | 12607 +++ .../translations/context/interface/host.v | 1458 + .../context/interface/host/dummy.json | 9113 ++ .../context/interface/host/dummy.v | 1563 + .../context/interface/journaled_state.json | 13250 +++ .../context/interface/journaled_state.v | 1976 + .../context/interface/result.json | 52298 +++++++++++ .../translations/context/interface/result.v | 9146 ++ .../context/interface/transaction.json | 16031 ++++ .../context/interface/transaction.v | 3101 + .../interface/transaction/access_list.json | 3476 + .../interface/transaction/access_list.v | 663 + .../context/interface/transaction/common.json | 4244 + .../context/interface/transaction/common.v | 615 + .../interface/transaction/eip1559.json | 4836 + .../context/interface/transaction/eip1559.v | 741 + .../interface/transaction/eip2930.json | 3560 + .../context/interface/transaction/eip2930.v | 542 + .../interface/transaction/eip4844.json | 5018 ++ .../context/interface/transaction/eip4844.v | 848 + .../interface/transaction/eip7702.json | 6681 ++ .../context/interface/transaction/eip7702.v | 1151 + .../context/interface/transaction/legacy.json | 2834 + .../context/interface/transaction/legacy.v | 397 + .../transaction/transaction_type.json | 1796 + .../interface/transaction/transaction_type.v | 303 + .../translations/context/journaled_state.json | 74432 ++++++++++++++++ .../translations/context/journaled_state.v | 14243 +++ CoqOfRust/revm/translations/context/tx.json | 10709 +++ CoqOfRust/revm/translations/context/tx.v | 2164 + .../translations/specification/constants.json | 147 + .../translations/specification/eip170.json | 39 + .../revm/translations/specification/eip2.json | 371 + .../translations/specification/eip4844.json | 344 + .../eip7702/authorization_list.json | 7836 ++ .../specification/eip7702/constants.json | 76 + .../eip7702/recovered_authorization.json | 2931 + .../translations/specification/hardfork.json | 9542 ++ 60 files changed, 352784 insertions(+), 2 deletions(-) create mode 100644 CoqOfRust/revm/of_json/common.v create mode 100644 CoqOfRust/revm/of_json/context.py create mode 100644 CoqOfRust/revm/of_json/context/interface/host.v create mode 100644 CoqOfRust/revm/of_json/of_json.py create mode 100644 CoqOfRust/revm/of_json/specification.py create mode 100644 CoqOfRust/revm/of_json/specification/hardfork.v create mode 100644 CoqOfRust/revm/translations/context/block.json create mode 100644 CoqOfRust/revm/translations/context/block.v create mode 100644 CoqOfRust/revm/translations/context/cfg.json create mode 100644 CoqOfRust/revm/translations/context/cfg.v create mode 100644 CoqOfRust/revm/translations/context/context.json create mode 100644 CoqOfRust/revm/translations/context/context.v create mode 100644 CoqOfRust/revm/translations/context/interface/block.json create mode 100644 CoqOfRust/revm/translations/context/interface/block.v create mode 100644 CoqOfRust/revm/translations/context/interface/block/blob.json create mode 100644 CoqOfRust/revm/translations/context/interface/block/blob.v create mode 100644 CoqOfRust/revm/translations/context/interface/cfg.json create mode 100644 CoqOfRust/revm/translations/context/interface/cfg.v create mode 100644 CoqOfRust/revm/translations/context/interface/errors.json create mode 100644 CoqOfRust/revm/translations/context/interface/errors.v create mode 100644 CoqOfRust/revm/translations/context/interface/host.json create mode 100644 CoqOfRust/revm/translations/context/interface/host.v create mode 100644 CoqOfRust/revm/translations/context/interface/host/dummy.json create mode 100644 CoqOfRust/revm/translations/context/interface/host/dummy.v create mode 100644 CoqOfRust/revm/translations/context/interface/journaled_state.json create mode 100644 CoqOfRust/revm/translations/context/interface/journaled_state.v create mode 100644 CoqOfRust/revm/translations/context/interface/result.json create mode 100644 CoqOfRust/revm/translations/context/interface/result.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/access_list.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/access_list.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/common.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/common.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip1559.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip1559.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip2930.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip2930.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip4844.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip4844.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip7702.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/eip7702.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/legacy.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/legacy.v create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/transaction_type.json create mode 100644 CoqOfRust/revm/translations/context/interface/transaction/transaction_type.v create mode 100644 CoqOfRust/revm/translations/context/journaled_state.json create mode 100644 CoqOfRust/revm/translations/context/journaled_state.v create mode 100644 CoqOfRust/revm/translations/context/tx.json create mode 100644 CoqOfRust/revm/translations/context/tx.v create mode 100644 CoqOfRust/revm/translations/specification/constants.json create mode 100644 CoqOfRust/revm/translations/specification/eip170.json create mode 100644 CoqOfRust/revm/translations/specification/eip2.json create mode 100644 CoqOfRust/revm/translations/specification/eip4844.json create mode 100644 CoqOfRust/revm/translations/specification/eip7702/authorization_list.json create mode 100644 CoqOfRust/revm/translations/specification/eip7702/constants.json create mode 100644 CoqOfRust/revm/translations/specification/eip7702/recovered_authorization.json create mode 100644 CoqOfRust/revm/translations/specification/hardfork.json diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index be002b09d..5ebfcea62 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -92,6 +92,20 @@ jobs: cp ../../rust-toolchain ./ cd crates # We compile each library twice to avoid errors. TODO: investigate why this is needed + # context + cd context + cargo coq-of-rust + touch src/lib.rs + cargo coq-of-rust --with-json + rsync -acv src/ ../../../../CoqOfRust/revm/translations/context/ --include='*/' --include='*.v' --include='*.json' --exclude='*' + cd .. + # context/interface + cd context/interface + cargo coq-of-rust + touch src/lib.rs + cargo coq-of-rust --with-json + rsync -acv src/ ../../../../../CoqOfRust/revm/translations/context/interface/ --include='*/' --include='*.v' --include='*.json' --exclude='*' + cd ../.. # interpreter cd interpreter cargo coq-of-rust @@ -124,8 +138,8 @@ jobs: cd specification cargo coq-of-rust touch src/lib.rs - cargo coq-of-rust - rsync -acv src/ ../../../../CoqOfRust/revm/translations/specification/ --include='*/' --include='*.v' --exclude='*' + cargo coq-of-rust --with-json + rsync -acv src/ ../../../../CoqOfRust/revm/translations/specification/ --include='*/' --include='*.v' --include='*.json' --exclude='*' cd .. cd ../../.. endGroup diff --git a/.gitignore b/.gitignore index 14279f64a..7f3f0e42b 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,6 @@ # Generated files for the smart contracts contracts/generated + +# Python +__pycache__/ diff --git a/CoqOfRust/revm/of_json/common.v b/CoqOfRust/revm/of_json/common.v new file mode 100644 index 000000000..9e36d8ac3 --- /dev/null +++ b/CoqOfRust/revm/of_json/common.v @@ -0,0 +1,9 @@ +Require Import CoqOfRust.CoqOfRust. +Require Import simulations.M. + +Module ruint. + Module Uint. + Definition t (BITS LIMBS : Z) : Set := + Z. + End Uint. +End ruint. diff --git a/CoqOfRust/revm/of_json/context.py b/CoqOfRust/revm/of_json/context.py new file mode 100644 index 000000000..7535d4e58 --- /dev/null +++ b/CoqOfRust/revm/of_json/context.py @@ -0,0 +1,14 @@ +import json +import of_json as o + +crate = "context" + +def interface_host(): + input = json.load(open('../translations/context/interface/host.json')) + output = o.get_header([]) + output += "\n" + output += o.pp_top_level_item(*o.find_top_level_item_by_name(crate, input, "SStoreResult")) + with open('context/interface/host.v', 'w') as f: + f.write(output) + +interface_host() diff --git a/CoqOfRust/revm/of_json/context/interface/host.v b/CoqOfRust/revm/of_json/context/interface/host.v new file mode 100644 index 000000000..6a414a8ec --- /dev/null +++ b/CoqOfRust/revm/of_json/context/interface/host.v @@ -0,0 +1,26 @@ +(* Generated file. Do not edit. *) +Require Import CoqOfRust.CoqOfRust. +Require Import simulations.M. + +Module SStoreResult. + Record t : Set := { + original_value: ruint.Uint.t 256 4; + present_value: ruint.Uint.t 256 4; + new_value: ruint.Uint.t 256 4; + }. + + Definition current_to_value (x: t) : Value.t := + match x with + | Build_t original_value present_value new_value => + Value.StructRecord "context::host::SStoreResult" [ + ("original_value", to_value original_value); + ("present_value", to_value present_value); + ("new_value", to_value new_value) + ] + end. + + Global Instance IsLink : Link t := { + to_ty := Ty.path "context::host::SStoreResult"; + to_value := to_value + }. +End SStoreResult. \ No newline at end of file diff --git a/CoqOfRust/revm/of_json/of_json.py b/CoqOfRust/revm/of_json/of_json.py new file mode 100644 index 000000000..e33138baf --- /dev/null +++ b/CoqOfRust/revm/of_json/of_json.py @@ -0,0 +1,248 @@ +""" +Utility functions to generate Coq files from the JSON generated by `coq-of-rust`. +""" + + +from typing import Any, Tuple + + +def find_top_level_item(prefix: list[str], top_level, condition) -> Tuple[list[str], Any] | None: + for entry in top_level: + item = entry["item"] + if condition(item): + return (prefix, item) + if "Module" in item: + module = item["Module"] + result = find_top_level_item(prefix + [module["name"]], module["body"], condition) + if result: + return result + + +def find_top_level_item_by_name(crate: str, top_level, name: str) -> Tuple[list[str], Any]: + def item_has_name(item): + if isinstance(item, dict): + item = next(iter(item.values())) + return "name" in item and item["name"] == name + return False + + result = find_top_level_item( + [crate], + top_level, + item_has_name, + ) + if result: + return result + raise Exception("Item not found: " + name) + + +def get_header(imports: list[str]) -> str: + return """(* Generated file. Do not edit. *) +Require Import CoqOfRust.CoqOfRust. +Require Import simulations.M. +""" + "".join("Require " + import_ + ".\n" for import_ in imports) + + +def indent(s: str) -> str: + return "\n".join( + # We do not indent empty lines + " " + line if len(line) > 0 else "" + for line in s.split("\n") + ) + + +def paren(with_paren: bool, s: str) -> str: + if with_paren: + return "(" + s + ")" + return s + + +def pp_path(path) -> str: + return ".".join(path) + + +def pp_const(const) -> str: + if "Literal" in const: + const = const["Literal"] + if "Integer" in const: + integer = const["Integer"] + return str(integer["value"]) + return "Unknown literal " + str(const) + return "Unknown const " + str(const) + + + +def pp_type(with_paren: bool, item) -> str: + if "Var" in item: + item = item["Var"] + return item["name"] + if "Path" in item: + item = item["Path"] + path = item["path"] + if path == ["*const"]: + return "Ref.t Pointer.Kind.ConstPointer" + if path == ["bool"]: + return "bool" + return pp_path(path) + ".t" + if "Application" in item: + item = item["Application"] + return paren( + with_paren and len(item["consts"]) + len(item["tys"]) > 0, + " ".join( + [pp_type(True, item["func"])] + + [pp_const(const) for const in item["consts"]] + + [pp_type(True, ty) for ty in item["tys"]] + ) + ) + if "Tuple" in item: + item = item["Tuple"] + return paren( + with_paren, + " * ".join(pp_type(True, ty) for ty in item["tys"]) + ) + return "Unknown type " + str(item) + + +def pp_type_struct_struct(prefix: list[str], item) -> str: + def get_ty_params(is_implicit: bool) -> str: + if len(item["ty_params"]) != 0: + return \ + ("{" if is_implicit else "(") + \ + " ".join(item["ty_params"]) + \ + ": Set" + \ + ("}" if is_implicit else ")") + \ + " " + else: + return "" + + def get_applied_ty() -> str: + if len(item["ty_params"]) != 0: + return "t" + "".join(" " + ty_param for ty_param in item["ty_params"]) + else: + return "t" + + ty_params_links = "".join("`{Link " + ty_param + "} " for ty_param in item["ty_params"]) + full_name = "::".join(prefix + [item["name"]]) + return pp_module(item["name"], + "Record t " + get_ty_params(True) + ": Set := {\n" + + indent("".join( + field[0] + ": " + pp_type(False, field[1]) + ";\n" + for field in item["fields"] + )) + + "}.\n" + + ("Arguments Build_t {" + " ".join(["_"] * len(item["ty_params"])) + "}.\n" + + "Arguments t : clear implicits.\n" + if len(item["ty_params"]) > 0 + else "" + ) + + "\n" + + f"Definition current_to_value {get_ty_params(True)}(x: {get_applied_ty()}) : Value.t :=\n" + + indent( + "match x with\n" + + "| Build_t" + "".join(" " + field[0] for field in item["fields"]) + " =>\n" + + indent( + f"Value.StructRecord \"{full_name}\" [\n" + + indent(";\n".join( + "(\"" + field[0] + "\", to_value " + field[0] + ")" + for field in item["fields"] + )) + "\n" + + "]\n" + ) + + "end.\n" + ) + + "\n" + + "Global Instance IsLink " + get_ty_params(True) + ty_params_links + ": Link " + + paren(len(item["ty_params"]) > 0, " ".join(["t"] + item["ty_params"])) + + " := {\n" + + indent( + "to_ty := Ty.path \"" + full_name + "\";\n" + + "to_value := to_value\n" + ) + + "}." + ) + + +def pp_type_struct_tuple(prefix: list[str], item) -> str: + if len(item["ty_params"]) != 0: + ty_params = "(" + " ".join(item["ty_params"]) + ": Set) " + else: + ty_params = "" + ty_params_links = "".join("`{Link " + ty_param + "} " for ty_param in item["ty_params"]) + return pp_module(item["name"], + "Inductive t " + ty_params + ": Set :=\n" + + "| Make :" + + "".join( + " " + pp_type(False, field) + " ->" + for field in item["fields"] + ) + + " t" + "".join(" " + ty_param for ty_param in item["ty_params"]) + ".\n" + + ("Arguments Make {" + " ".join(["_"] * len(item["ty_params"])) + "}.\n" + if len(item["ty_params"]) > 0 + else "" + ) + + "\n" + + "Global Instance IsLink " + ty_params + ty_params_links + ": Link " + + paren(len(item["ty_params"]) > 0, " ".join(["t"] + item["ty_params"])) + + " := {\n" + + indent( + "to_ty := Ty.path \"" + "::".join(prefix + [item["name"]]) + "\";\n" + + "to_value '(Make" + "".join(" x" + str(index) for index in range(len(item["fields"]))) + ") :=\n" + + indent( + "Value.StructTuple \"" + "::".join(prefix + [item["name"]]) + "\" [" + + "; ".join("to_value x" + str(index) for index in range(len(item["fields"]))) + "];\n" + ) + ) + + "}." + ) + + +def pp_type_enum(prefix: list[str], item) -> str: + name = item["name"] + variants = item["variants"] + + if len(item["ty_params"]) != 0: + ty_params = "(" + " ".join(item["ty_params"]) + ": Set) " + ty_params_args = "".join(" " + ty_param for ty_param in item["ty_params"]) + else: + ty_params = "" + ty_params_args = "" + + # Generate the inductive type definition + inductive_def = f"Inductive t {ty_params}: Set :=\n" + for variant in variants: + variant_name = variant["name"] + if "Tuple" in variant["item"] and len(variant["item"]["Tuple"]["tys"]) == 0: + inductive_def += f"| {variant_name}\n" + else: + tys = variant["item"]["tys"] + inductive_def += f"| {variant_name} : {' -> '.join(pp_type(False, ty) for ty in tys)} -> t{ty_params_args}\n" + inductive_def += "." + + # Generate the Arguments line if there are type parameters + arguments_line = (f"Arguments {' '.join(variant['name'] for variant in variants)} " + + "{" + " ".join(["_"] * len(item["ty_params"])) + "}.\n" + ) if len(item["ty_params"]) > 0 else "" + + return pp_module(name, + inductive_def + + arguments_line + ) + + +def pp_top_level_item(prefix: list[str], item) -> str: + if "TypeStructStruct" in item: + item = item["TypeStructStruct"] + return pp_type_struct_struct(prefix, item) + if "TypeStructTuple" in item: + item = item["TypeStructTuple"] + return pp_type_struct_tuple(prefix, item) + if "TypeEnum" in item: + item = item["TypeEnum"] + return pp_type_enum(prefix, item) + return "Unknown item type " + str(item) + + +def pp_module(name: str, content: str) -> str: + return \ + "Module " + name + ".\n" + \ + indent(content) + "\n" + \ + "End " + name + "." diff --git a/CoqOfRust/revm/of_json/specification.py b/CoqOfRust/revm/of_json/specification.py new file mode 100644 index 000000000..3d79ae0c3 --- /dev/null +++ b/CoqOfRust/revm/of_json/specification.py @@ -0,0 +1,14 @@ +import json +import of_json as o + +crate = "specification" + +def hardfork(): + input = json.load(open('../translations/specification/hardfork.json')) + output = o.get_header([]) + output += "\n" + output += o.pp_top_level_item(*o.find_top_level_item_by_name(crate, input, "SpecId")) + with open('specification/hardfork.v', 'w') as f: + f.write(output) + +hardfork() diff --git a/CoqOfRust/revm/of_json/specification/hardfork.v b/CoqOfRust/revm/of_json/specification/hardfork.v new file mode 100644 index 000000000..f5139355d --- /dev/null +++ b/CoqOfRust/revm/of_json/specification/hardfork.v @@ -0,0 +1,29 @@ +(* Generated file. Do not edit. *) +Require Import CoqOfRust.CoqOfRust. +Require Import simulations.M. + +Module SpecId. + Inductive t : Set := + | FRONTIER + | FRONTIER_THAWING + | HOMESTEAD + | DAO_FORK + | TANGERINE + | SPURIOUS_DRAGON + | BYZANTIUM + | CONSTANTINOPLE + | PETERSBURG + | ISTANBUL + | MUIR_GLACIER + | BERLIN + | LONDON + | ARROW_GLACIER + | GRAY_GLACIER + | MERGE + | SHANGHAI + | CANCUN + | PRAGUE + | OSAKA + | LATEST + . +End SpecId. \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/block.json b/CoqOfRust/revm/translations/context/block.json new file mode 100644 index 000000000..f9b9e4c79 --- /dev/null +++ b/CoqOfRust/revm/translations/context/block.json @@ -0,0 +1,5616 @@ +[ + { + "file_name": "crates/context/src/block.rs", + "item": { + "Module": { + "name": "block", + "body": [ + { + "file_name": "crates/context/src/block.rs", + "item": { + "TypeStructStruct": { + "name": "BlockEnv", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "number", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "beneficiary", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "timestamp", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "gas_limit", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "basefee", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "difficulty", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "prevrandao", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + [ + "blob_excess_gas_and_price", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ], + "fields": [ + [ + "number", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "beneficiary", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "timestamp", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_limit", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "basefee", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "difficulty", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "prevrandao", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "blob_excess_gas_and_price", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "names", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "number" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "beneficiary" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "timestamp" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_limit" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "basefee" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "difficulty" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "prevrandao" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob_excess_gas_and_price" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "values", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_fields_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlockEnv" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "names" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "values" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "set_blob_excess_gas_and_price", + "snippet": [ + " pub fn set_blob_excess_gas_and_price(&mut self, excess_blob_gas: u64) {", + " self.blob_excess_gas_and_price = Some(BlobExcessGasAndPrice::new(excess_blob_gas));", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "excess_blob_gas", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "excess_blob_gas", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "Block" + ], + "trait_ty_params": [], + "items": [ + { + "name": "number", + "snippet": [ + " fn number(&self) -> u64 {", + " self.number", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "beneficiary", + "snippet": [ + " fn beneficiary(&self) -> Address {", + " self.beneficiary", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "beneficiary" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "timestamp", + "snippet": [ + " fn timestamp(&self) -> u64 {", + " self.timestamp", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "timestamp" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + " fn gas_limit(&self) -> u64 {", + " self.gas_limit", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "basefee", + "snippet": [ + " fn basefee(&self) -> u64 {", + " self.basefee", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "basefee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "difficulty", + "snippet": [ + " fn difficulty(&self) -> U256 {", + " self.difficulty", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "difficulty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "prevrandao", + "snippet": [ + " fn prevrandao(&self) -> Option {", + " self.prevrandao", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "prevrandao" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas_and_price", + "snippet": [ + " fn blob_excess_gas_and_price(&self) -> Option {", + " self.blob_excess_gas_and_price", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::block::BlockEnv" + }, + { + "InternalString": "blob_excess_gas_and_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_gasprice", + "snippet": null, + "kind": "Default" + }, + { + "name": "blob_excess_gas", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + " fn default() -> Self {", + " Self {", + " number: 0,", + " beneficiary: Address::ZERO,", + " timestamp: 1,", + " gas_limit: u64::MAX,", + " basefee: 0,", + " difficulty: U256::ZERO,", + " prevrandao: Some(B256::ZERO),", + " blob_excess_gas_and_price: Some(BlobExcessGasAndPrice::new(0)),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ], + "fields": [ + [ + "number", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + [ + "beneficiary", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "address", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "timestamp", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + [ + "gas_limit", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "core", + "num", + "MAX" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "basefee", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + [ + "difficulty", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "prevrandao", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + [ + "blob_excess_gas_and_price", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/block.v b/CoqOfRust/revm/translations/context/block.v new file mode 100644 index 000000000..c18273fb5 --- /dev/null +++ b/CoqOfRust/revm/translations/context/block.v @@ -0,0 +1,1055 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module block. + (* StructRecord + { + name := "BlockEnv"; + const_params := []; + ty_params := []; + fields := + [ + ("number", Ty.path "u64"); + ("beneficiary", Ty.path "alloy_primitives::bits::address::Address"); + ("timestamp", Ty.path "u64"); + ("gas_limit", Ty.path "u64"); + ("basefee", Ty.path "u64"); + ("difficulty", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("prevrandao", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ]); + ("blob_excess_gas_and_price", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ]) + ]; + } *) + + Module Impl_core_clone_Clone_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context::block::BlockEnv" + [ + ("number", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "number" + |) + ] + |)); + ("beneficiary", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "beneficiary" + |) + ] + |)); + ("timestamp", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "timestamp" + |) + ] + |)); + ("gas_limit", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "gas_limit" + |) + ] + |)); + ("basefee", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "basefee" + |) + ] + |)); + ("difficulty", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "difficulty" + |) + ] + |)); + ("prevrandao", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "prevrandao" + |) + ] + |)); + ("blob_excess_gas_and_price", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_block_BlockEnv. + + Module Impl_core_fmt_Debug_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ names := + M.alloc (| + M.alloc (| + Value.Array + [ + M.read (| Value.String "number" |); + M.read (| Value.String "beneficiary" |); + M.read (| Value.String "timestamp" |); + M.read (| Value.String "gas_limit" |); + M.read (| Value.String "basefee" |); + M.read (| Value.String "difficulty" |); + M.read (| Value.String "prevrandao" |); + M.read (| Value.String "blob_excess_gas_and_price" |) + ] + |) + |) in + let~ values := + M.alloc (| + M.alloc (| + Value.Array + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "number" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "beneficiary" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "timestamp" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "gas_limit" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "basefee" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "difficulty" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "prevrandao" + |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |) + |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_fields_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "BlockEnv" |); + M.read (| names |); + M.read (| values |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_block_BlockEnv. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_block_BlockEnv. + + Module Impl_core_cmp_PartialEq_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "number" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "number" + |) + |) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::bits::address::Address", + [ Ty.path "alloy_primitives::bits::address::Address" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "beneficiary" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "beneficiary" + |) + ] + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "timestamp" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "timestamp" + |) + |) + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "gas_limit" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "gas_limit" + |) + |) + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "basefee" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "basefee" + |) + |) + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "difficulty" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "difficulty" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "prevrandao" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "prevrandao" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ], + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_block_BlockEnv. + + Module Impl_core_cmp_Eq_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_block_BlockEnv. + + Module Impl_core_hash_Hash_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "number" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "beneficiary" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "timestamp" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "gas_limit" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "basefee" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "hash", + [ __H ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "difficulty" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + [], + "hash", + [ __H ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "prevrandao" + |); + M.read (| state |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ], + [], + "hash", + [ __H ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |); + M.read (| state |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_block_BlockEnv. + + Module Impl_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* + pub fn set_blob_excess_gas_and_price(&mut self, excess_blob_gas: u64) { + self.blob_excess_gas_and_price = Some(BlobExcessGasAndPrice::new(excess_blob_gas)); + } + *) + Definition set_blob_excess_gas_and_price + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self; excess_blob_gas ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let excess_blob_gas := M.alloc (| excess_blob_gas |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |), + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "new", + [] + |), + [ M.read (| excess_blob_gas |) ] + |) + ] + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_set_blob_excess_gas_and_price : + M.IsAssociatedFunction Self "set_blob_excess_gas_and_price" set_blob_excess_gas_and_price. + End Impl_revm_context_block_BlockEnv. + + Module Impl_revm_context_interface_block_Block_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* + fn number(&self) -> u64 { + self.number + } + *) + Definition number (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "number" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn beneficiary(&self) -> Address { + self.beneficiary + } + *) + Definition beneficiary (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "beneficiary" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn timestamp(&self) -> u64 { + self.timestamp + } + *) + Definition timestamp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "timestamp" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn gas_limit(&self) -> u64 { + self.gas_limit + } + *) + Definition gas_limit (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "gas_limit" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn basefee(&self) -> u64 { + self.basefee + } + *) + Definition basefee (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "basefee" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn difficulty(&self) -> U256 { + self.difficulty + } + *) + Definition difficulty (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "difficulty" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn prevrandao(&self) -> Option { + self.prevrandao + } + *) + Definition prevrandao (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "prevrandao" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn blob_excess_gas_and_price(&self) -> Option { + self.blob_excess_gas_and_price + } + *) + Definition blob_excess_gas_and_price + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::block::BlockEnv", + "blob_excess_gas_and_price" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::block::Block" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("number", InstanceField.Method number); + ("beneficiary", InstanceField.Method beneficiary); + ("timestamp", InstanceField.Method timestamp); + ("gas_limit", InstanceField.Method gas_limit); + ("basefee", InstanceField.Method basefee); + ("difficulty", InstanceField.Method difficulty); + ("prevrandao", InstanceField.Method prevrandao); + ("blob_excess_gas_and_price", InstanceField.Method blob_excess_gas_and_price) + ]. + End Impl_revm_context_interface_block_Block_for_revm_context_block_BlockEnv. + + Module Impl_core_default_Default_for_revm_context_block_BlockEnv. + Definition Self : Ty.t := Ty.path "revm_context::block::BlockEnv". + + (* + fn default() -> Self { + Self { + number: 0, + beneficiary: Address::ZERO, + timestamp: 1, + gas_limit: u64::MAX, + basefee: 0, + difficulty: U256::ZERO, + prevrandao: Some(B256::ZERO), + blob_excess_gas_and_price: Some(BlobExcessGasAndPrice::new(0)), + } + } + *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context::block::BlockEnv" + [ + ("number", Value.Integer IntegerKind.U64 0); + ("beneficiary", + M.read (| M.get_constant (| "alloy_primitives::bits::address::ZERO" |) |)); + ("timestamp", Value.Integer IntegerKind.U64 1); + ("gas_limit", M.read (| M.get_constant (| "core::num::MAX" |) |)); + ("basefee", Value.Integer IntegerKind.U64 0); + ("difficulty", M.read (| M.get_constant (| "ruint::ZERO" |) |)); + ("prevrandao", + Value.StructTuple + "core::option::Option::Some" + [ M.read (| M.get_constant (| "alloy_primitives::bits::fixed::ZERO" |) |) ]); + ("blob_excess_gas_and_price", + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "new", + [] + |), + [ Value.Integer IntegerKind.U64 0 ] + |) + ]) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_block_BlockEnv. +End block. diff --git a/CoqOfRust/revm/translations/context/cfg.json b/CoqOfRust/revm/translations/context/cfg.json new file mode 100644 index 000000000..0022863cb --- /dev/null +++ b/CoqOfRust/revm/translations/context/cfg.json @@ -0,0 +1,3620 @@ +[ + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "Module": { + "name": "cfg", + "body": [ + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TypeStructStruct": { + "name": "CfgEnv", + "const_params": [], + "ty_params": [ + "SPEC" + ], + "fields": [ + [ + "chain_id", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "spec", + { + "Var": { + "name": "SPEC" + } + } + ], + [ + "limit_contract_code_size", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ], + [ + "disable_nonce_check", + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + }, + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ], + "fields": [ + [ + "chain_id", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "spec", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "SPEC" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "limit_contract_code_size", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "limit_contract_code_size" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "disable_nonce_check", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "disable_nonce_check" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + }, + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field4_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CfgEnv" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "chain_id" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "spec" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "limit_contract_code_size" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "limit_contract_code_size" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "disable_nonce_check" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "disable_nonce_check" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + }, + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + }, + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Var": { + "name": "SPEC" + } + }, + "trait_tys": [ + { + "Var": { + "name": "SPEC" + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "limit_contract_code_size" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "limit_contract_code_size" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "disable_nonce_check" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "disable_nonce_check" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "items": [ + { + "name": "with_chain_id", + "snippet": [ + " pub fn with_chain_id(mut self, chain_id: u64) -> Self {", + " self.chain_id = chain_id;", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "chain_id", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "chain_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "chain_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "SPEC" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "convert", + "Into" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Copy" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "SPEC" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Spec", + "snippet": [ + " type Spec = SPEC;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "SPEC" + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + " fn chain_id(&self) -> u64 {", + " self.chain_id", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "spec", + "snippet": [ + " fn spec(&self) -> Self::Spec {", + " self.spec", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_code_size", + "snippet": [ + " fn max_code_size(&self) -> usize {", + " self.limit_contract_code_size.unwrap_or(MAX_CODE_SIZE)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "func": "unwrap_or", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "limit_contract_code_size" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "constants", + "MAX_CODE_SIZE" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_eip3607_disabled", + "snippet": [ + " fn is_eip3607_disabled(&self) -> bool {", + " cfg_if::cfg_if! {", + " if #[cfg(feature = \"optional_eip3607\")] {", + " self.disable_eip3607", + " } else {", + " false", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "Bool": false + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_balance_check_disabled", + "snippet": [ + " fn is_balance_check_disabled(&self) -> bool {", + " cfg_if::cfg_if! {", + " if #[cfg(feature = \"optional_balance_check\")] {", + " self.disable_balance_check", + " } else {", + " false", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "Bool": false + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_gas_refund_disabled", + "snippet": [ + " fn is_gas_refund_disabled(&self) -> bool {", + " cfg_if::cfg_if! {", + " if #[cfg(feature = \"optional_gas_refund\")] {", + " self.disable_gas_refund", + " } else {", + " false", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "Bool": false + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_block_gas_limit_disabled", + "snippet": [ + " fn is_block_gas_limit_disabled(&self) -> bool {", + " cfg_if::cfg_if! {", + " if #[cfg(feature = \"optional_block_gas_limit\")] {", + " self.disable_block_gas_limit", + " } else {", + " false", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "Bool": false + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_nonce_check_disabled", + "snippet": [ + " fn is_nonce_check_disabled(&self) -> bool {", + " self.disable_nonce_check", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::cfg::CfgEnv" + }, + { + "InternalString": "disable_nonce_check" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_base_fee_check_disabled", + "snippet": [ + " fn is_base_fee_check_disabled(&self) -> bool {", + " cfg_if::cfg_if! {", + " if #[cfg(feature = \"optional_no_base_fee\")] {", + " self.disable_base_fee", + " } else {", + " false", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "SPEC" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "Bool": false + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + " fn default() -> Self {", + " Self {", + " chain_id: 1,", + " limit_contract_code_size: None,", + " spec: SpecId::PRAGUE,", + " disable_nonce_check: false,", + " #[cfg(feature = \"memory_limit\")]", + " memory_limit: (1 << 32) - 1,", + " #[cfg(feature = \"optional_balance_check\")]", + " disable_balance_check: false,", + " #[cfg(feature = \"optional_block_gas_limit\")]", + " disable_block_gas_limit: false,", + " #[cfg(feature = \"optional_eip3607\")]", + " disable_eip3607: false,", + " #[cfg(feature = \"optional_gas_refund\")]", + " disable_gas_refund: false,", + " #[cfg(feature = \"optional_no_base_fee\")]", + " disable_base_fee: false,", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ], + "fields": [ + [ + "chain_id", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + [ + "limit_contract_code_size", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + [ + "spec", + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "PRAGUE" + ], + "fields": [] + } + } + ], + [ + "disable_nonce_check", + { + "Literal": { + "Bool": false + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/cfg.v b/CoqOfRust/revm/translations/context/cfg.v new file mode 100644 index 000000000..f7558e6b1 --- /dev/null +++ b/CoqOfRust/revm/translations/context/cfg.v @@ -0,0 +1,680 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module cfg. + (* StructRecord + { + name := "CfgEnv"; + const_params := []; + ty_params := [ "SPEC" ]; + fields := + [ + ("chain_id", Ty.path "u64"); + ("spec", SPEC); + ("limit_contract_code_size", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ]); + ("disable_nonce_check", Ty.path "bool") + ]; + } *) + + Module Impl_core_clone_Clone_where_core_clone_Clone_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + (* Clone *) + Definition clone (SPEC : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context::cfg::CfgEnv" + [ + ("chain_id", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "chain_id" + |) + ] + |)); + ("spec", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", SPEC, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "spec" + |) + ] + |)); + ("limit_contract_code_size", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "limit_contract_code_size" + |) + ] + |)); + ("disable_nonce_check", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "disable_nonce_check" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone SPEC)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + (* Debug *) + Definition fmt (SPEC : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field4_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "CfgEnv" |); + M.read (| Value.String "chain_id" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "chain_id" + |); + M.read (| Value.String "spec" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "spec" + |); + M.read (| Value.String "limit_contract_code_size" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "limit_contract_code_size" + |); + M.read (| Value.String "disable_nonce_check" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "disable_nonce_check" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt SPEC)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method (assert_receiver_is_total_eq SPEC)) + ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_core_marker_StructuralPartialEq_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + (* PartialEq *) + Definition eq (SPEC : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "chain_id" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::cfg::CfgEnv", + "chain_id" + |) + |) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| "core::cmp::PartialEq", SPEC, [ SPEC ], "eq", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "spec" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::cfg::CfgEnv", + "spec" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ], + [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ] ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "limit_contract_code_size" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::cfg::CfgEnv", + "limit_contract_code_size" + |) + ] + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "disable_nonce_check" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::cfg::CfgEnv", + "disable_nonce_check" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq SPEC)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_SPEC_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId. + Definition Self : Ty.t := + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]. + + (* + pub fn with_chain_id(mut self, chain_id: u64) -> Self { + self.chain_id = chain_id; + self + } + *) + Definition with_chain_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; chain_id ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let chain_id := M.alloc (| chain_id |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::cfg::CfgEnv", + "chain_id" + |), + M.read (| chain_id |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_chain_id : + M.IsAssociatedFunction Self "with_chain_id" with_chain_id. + End Impl_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId. + + Module Impl_revm_context_interface_cfg_Cfg_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_where_core_marker_Copy_SPEC_for_revm_context_cfg_CfgEnv_SPEC. + Definition Self (SPEC : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::cfg::CfgEnv") [] [ SPEC ]. + + (* type Spec = SPEC; *) + Definition _Spec (SPEC : Ty.t) : Ty.t := SPEC. + + (* + fn chain_id(&self) -> u64 { + self.chain_id + } + *) + Definition chain_id (SPEC : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "chain_id" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn spec(&self) -> Self::Spec { + self.spec + } + *) + Definition spec (SPEC : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "spec" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn max_code_size(&self) -> usize { + self.limit_contract_code_size.unwrap_or(MAX_CODE_SIZE) + } + *) + Definition max_code_size + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ], + "unwrap_or", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "limit_contract_code_size" + |) + |); + M.read (| M.get_constant (| "revm_specification::constants::MAX_CODE_SIZE" |) |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_eip3607_disabled(&self) -> bool { + cfg_if::cfg_if! { + if #[cfg(feature = "optional_eip3607")] { + self.disable_eip3607 + } else { + false + } + } + } + *) + Definition is_eip3607_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Bool false)) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_balance_check_disabled(&self) -> bool { + cfg_if::cfg_if! { + if #[cfg(feature = "optional_balance_check")] { + self.disable_balance_check + } else { + false + } + } + } + *) + Definition is_balance_check_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Bool false)) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_gas_refund_disabled(&self) -> bool { + cfg_if::cfg_if! { + if #[cfg(feature = "optional_gas_refund")] { + self.disable_gas_refund + } else { + false + } + } + } + *) + Definition is_gas_refund_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Bool false)) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_block_gas_limit_disabled(&self) -> bool { + cfg_if::cfg_if! { + if #[cfg(feature = "optional_block_gas_limit")] { + self.disable_block_gas_limit + } else { + false + } + } + } + *) + Definition is_block_gas_limit_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Bool false)) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_nonce_check_disabled(&self) -> bool { + self.disable_nonce_check + } + *) + Definition is_nonce_check_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::cfg::CfgEnv", + "disable_nonce_check" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_base_fee_check_disabled(&self) -> bool { + cfg_if::cfg_if! { + if #[cfg(feature = "optional_no_base_fee")] { + self.disable_base_fee + } else { + false + } + } + } + *) + Definition is_base_fee_check_disabled + (SPEC : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self SPEC in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Bool false)) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (SPEC : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::Cfg" + (Self SPEC) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Spec", InstanceField.Ty (_Spec SPEC)); + ("chain_id", InstanceField.Method (chain_id SPEC)); + ("spec", InstanceField.Method (spec SPEC)); + ("max_code_size", InstanceField.Method (max_code_size SPEC)); + ("is_eip3607_disabled", InstanceField.Method (is_eip3607_disabled SPEC)); + ("is_balance_check_disabled", InstanceField.Method (is_balance_check_disabled SPEC)); + ("is_gas_refund_disabled", InstanceField.Method (is_gas_refund_disabled SPEC)); + ("is_block_gas_limit_disabled", InstanceField.Method (is_block_gas_limit_disabled SPEC)); + ("is_nonce_check_disabled", InstanceField.Method (is_nonce_check_disabled SPEC)); + ("is_base_fee_check_disabled", InstanceField.Method (is_base_fee_check_disabled SPEC)) + ]. + End Impl_revm_context_interface_cfg_Cfg_where_core_convert_Into_SPEC_revm_specification_hardfork_SpecId_where_core_marker_Copy_SPEC_for_revm_context_cfg_CfgEnv_SPEC. + + Module Impl_core_default_Default_for_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId. + Definition Self : Ty.t := + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]. + + (* + fn default() -> Self { + Self { + chain_id: 1, + limit_contract_code_size: None, + spec: SpecId::PRAGUE, + disable_nonce_check: false, + #[cfg(feature = "memory_limit")] + memory_limit: (1 << 32) - 1, + #[cfg(feature = "optional_balance_check")] + disable_balance_check: false, + #[cfg(feature = "optional_block_gas_limit")] + disable_block_gas_limit: false, + #[cfg(feature = "optional_eip3607")] + disable_eip3607: false, + #[cfg(feature = "optional_gas_refund")] + disable_gas_refund: false, + #[cfg(feature = "optional_no_base_fee")] + disable_base_fee: false, + } + } + *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context::cfg::CfgEnv" + [ + ("chain_id", Value.Integer IntegerKind.U64 1); + ("limit_contract_code_size", Value.StructTuple "core::option::Option::None" []); + ("spec", Value.StructTuple "revm_specification::hardfork::SpecId::PRAGUE" []); + ("disable_nonce_check", Value.Bool false) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId. +End cfg. diff --git a/CoqOfRust/revm/translations/context/context.json b/CoqOfRust/revm/translations/context/context.json new file mode 100644 index 000000000..71a4785e0 --- /dev/null +++ b/CoqOfRust/revm/translations/context/context.json @@ -0,0 +1,26582 @@ +[ + { + "file_name": "crates/context/src/context.rs", + "item": { + "Module": { + "name": "context", + "body": [ + { + "file_name": "crates/context/src/context.rs", + "item": { + "TypeStructStruct": { + "name": "Context", + "const_params": [], + "ty_params": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "fields": [ + [ + "block", + { + "Var": { + "name": "BLOCK" + } + } + ], + [ + "tx", + { + "Var": { + "name": "TX" + } + } + ], + [ + "cfg", + { + "Var": { + "name": "CFG" + } + } + ], + [ + "journaled_state", + { + "Var": { + "name": "JOURNAL" + } + } + ], + [ + "chain", + { + "Var": { + "name": "CHAIN" + } + } + ], + [ + "error", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CHAIN" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": "Associated" + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "#[derive_where(Clone, Debug; BLOCK, CFG, CHAIN, TX, DB, JOURNAL, ::Error)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_5", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_cfg", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_journaled_state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_chain", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_error", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_5" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "block", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "BLOCK" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "TX" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "CHAIN" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "error", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_error" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CHAIN" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": "Associated" + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "#[derive_where(Clone, Debug; BLOCK, CFG, CHAIN, TX, DB, JOURNAL, ::Error)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "__f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "__f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_5", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_cfg", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_journaled_state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_chain", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__field_error", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_5" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__builder", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Context" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "block" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "tx" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "cfg" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "journaled_state" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "chain" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "field", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "error" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__field_error" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "builders", + "DebugStruct" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "finish", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__builder" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + " fn default() -> Self {", + " Self::new(EmptyDB::new(), SpecId::LATEST)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + }, + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "items": [ + { + "name": "builder", + "snippet": [ + " pub fn builder() -> Self {", + " Self::new(EmptyDB::new(), SpecId::LATEST)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "block", + "BlockEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_database_interface", + "empty_db", + "EmptyDBTyped" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + }, + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "DB", + "JOURNAL", + "CHAIN" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "items": [ + { + "name": "new", + "snippet": [ + " pub fn new(db: DB, spec: SpecId) -> Self {", + " let mut journaled_state = JOURNAL::new(db);", + " journaled_state.set_spec_id(spec);", + " Self {", + " tx: TX::default(),", + " block: BLOCK::default(),", + " cfg: CfgEnv {", + " spec,", + " ..Default::default()", + " },", + " journaled_state,", + " chain: Default::default(),", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "db", + { + "Var": { + "name": "DB" + } + }, + null + ], + [ + "spec", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "db", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "db" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "spec", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "journaled_state", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "db" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "journaled_state" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "TX" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "BLOCK" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "cfg", + { + "StructStruct": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ], + "fields": [ + [ + "spec", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "cfg", + "CfgEnv" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "CHAIN" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "items": [ + { + "name": "code", + "snippet": [ + " pub fn code(", + " &mut self,", + " address: Address,", + " ) -> Result, ::Error> {", + " let a = self.journaled_state.load_account_code(address)?;", + " // SAFETY: Safe to unwrap as load_code will insert code if it is empty.", + " let code = a.info.code.as_ref().unwrap();", + " if code.is_eof() {", + " return Ok(Eip7702CodeLoad::new_not_delegated(", + " EOF_MAGIC_BYTES.clone(),", + " a.is_cold,", + " ));", + " }", + "", + " if let Bytecode::Eip7702(code) = code {", + " let address = code.address();", + " let is_cold = a.is_cold;", + "", + " let delegated_account = self.journaled_state.load_account_code(address)?;", + "", + " // SAFETY: Safe to unwrap as load_code will insert code if it is empty.", + " let delegated_code = delegated_account.info.code.as_ref().unwrap();", + "", + " let bytes = if delegated_code.is_eof() {", + " EOF_MAGIC_BYTES.clone()", + " } else {", + " delegated_code.original_bytes()", + " };", + "", + " return Ok(Eip7702CodeLoad::new(", + " StateLoad::new(bytes, is_cold),", + " delegated_account.is_cold,", + " ));", + " }", + "", + " Ok(Eip7702CodeLoad::new_not_delegated(", + " code.original_bytes(),", + " a.is_cold,", + " ))", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "a", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "a" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_eof", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_bytecode", + "eof", + "EOF_MAGIC_BYTES" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "a" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "LocalVar": "code" + }, + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_bytecode::bytecode::Bytecode::Eip7702" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "address", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "eip7702", + "Eip7702Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "a" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "delegated_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "delegated_code", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "delegated_account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "bytes", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_eof", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "delegated_code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_bytecode", + "eof", + "EOF_MAGIC_BYTES" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "original_bytes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "delegated_code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "bytes" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "delegated_account" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "original_bytes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "a" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_new_journal", + "snippet": [ + " pub fn with_new_journal>(", + " self,", + " mut journal: OJOURNAL,", + " ) -> Context {", + " journal.set_spec_id(self.cfg.spec().into());", + " Context {", + " tx: self.tx,", + " block: self.block,", + " cfg: self.cfg,", + " journaled_state: journal,", + " chain: self.chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "OJOURNAL" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "journal", + { + "Var": { + "name": "OJOURNAL" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "OJOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "journal", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "journal" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "OJOURNAL" + } + }, + "trait_tys": [], + "method_name": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "journal" + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journal" + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_db", + "snippet": [ + " pub fn with_db(", + " self,", + " db: ODB,", + " ) -> Context, CHAIN> {", + " let spec = self.cfg.spec().into();", + " let mut journaled_state = JournaledState::new(spec, db);", + " journaled_state.set_spec_id(spec);", + " Context {", + " tx: self.tx,", + " block: self.block,", + " cfg: self.cfg,", + " journaled_state,", + " chain: self.chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "ODB" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "db", + { + "Var": { + "name": "ODB" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "ODB" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "ODB" + } + } + ] + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "db", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "db" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "spec", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "journaled_state", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "ODB" + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "db" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "ODB" + } + } + ] + } + }, + "func": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "journaled_state" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_block", + "snippet": [ + " pub fn with_block(self, block: OB) -> Context {", + " Context {", + " tx: self.tx,", + " block,", + " cfg: self.cfg,", + " journaled_state: self.journaled_state,", + " chain: self.chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "OB" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "block", + { + "Var": { + "name": "OB" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "OB" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_tx", + "snippet": [ + " pub fn with_tx(", + " self,", + " tx: OTX,", + " ) -> Context {", + " Context {", + " tx,", + " block: self.block,", + " cfg: self.cfg,", + " journaled_state: self.journaled_state,", + " chain: self.chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "OTX" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "tx", + { + "Var": { + "name": "OTX" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "OTX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_chain", + "snippet": [ + " pub fn with_chain(self, chain: OC) -> Context {", + " Context {", + " tx: self.tx,", + " block: self.block,", + " cfg: self.cfg,", + " journaled_state: self.journaled_state,", + " chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "OC" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "chain", + { + "Var": { + "name": "OC" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "OC" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "chain", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "chain" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "chain" + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "with_cfg", + "snippet": [ + " pub fn with_cfg(", + " mut self,", + " cfg: OCFG,", + " ) -> Context {", + " self.journaled_state.set_spec_id(cfg.spec().into());", + " Context {", + " tx: self.tx,", + " block: self.block,", + " cfg,", + " journaled_state: self.journaled_state,", + " chain: self.chain,", + " error: Ok(()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "OCFG" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "cfg", + { + "Var": { + "name": "OCFG" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "OCFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "cfg", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "cfg" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "OCFG" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "cfg" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "context", + "Context" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + [ + "journaled_state", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "chain", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "error", + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_cfg_chained", + "snippet": [ + " pub fn modify_cfg_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut CFG),", + " {", + " f(&mut self.cfg);", + " self.journaled_state.set_spec_id(self.cfg.spec().into());", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_block_chained", + "snippet": [ + " pub fn modify_block_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut BLOCK),", + " {", + " self.modify_block(f);", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "modify_block", + "generic_tys": [ + { + "Var": { + "name": "F" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "self" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_tx_chained", + "snippet": [ + " pub fn modify_tx_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut TX),", + " {", + " self.modify_tx(f);", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "modify_tx", + "generic_tys": [ + { + "Var": { + "name": "F" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "self" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_chain_chained", + "snippet": [ + " pub fn modify_chain_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut CHAIN),", + " {", + " self.modify_chain(f);", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "modify_chain", + "generic_tys": [ + { + "Var": { + "name": "F" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "self" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_db_chained", + "snippet": [ + " pub fn modify_db_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut DB),", + " {", + " self.modify_db(f);", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "modify_db", + "generic_tys": [ + { + "Var": { + "name": "F" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "self" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_journal_chained", + "snippet": [ + " pub fn modify_journal_chained(mut self, f: F) -> Self", + " where", + " F: FnOnce(&mut JOURNAL),", + " {", + " self.modify_journal(f);", + " self", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "modify_journal", + "generic_tys": [ + { + "Var": { + "name": "F" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "self" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "self" + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_block", + "snippet": [ + " pub fn modify_block(&mut self, f: F)", + " where", + " F: FnOnce(&mut BLOCK),", + " {", + " f(&mut self.block);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_tx", + "snippet": [ + " pub fn modify_tx(&mut self, f: F)", + " where", + " F: FnOnce(&mut TX),", + " {", + " f(&mut self.tx);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "TX" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_cfg", + "snippet": [ + " pub fn modify_cfg(&mut self, f: F)", + " where", + " F: FnOnce(&mut CFG),", + " {", + " f(&mut self.cfg);", + " self.journaled_state.set_spec_id(self.cfg.spec().into());", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "set_spec_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_chain", + "snippet": [ + " pub fn modify_chain(&mut self, f: F)", + " where", + " F: FnOnce(&mut CHAIN),", + " {", + " f(&mut self.chain);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "chain" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_db", + "snippet": [ + " pub fn modify_db(&mut self, f: F)", + " where", + " F: FnOnce(&mut DB),", + " {", + " f(self.journaled_state.db());", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "db", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "modify_journal", + "snippet": [ + " pub fn modify_journal(&mut self, f: F)", + " where", + " F: FnOnce(&mut JOURNAL),", + " {", + " f(&mut self.journaled_state);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "JOURNAL" + } + } + ] + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code_hash", + "snippet": [ + " pub fn code_hash(", + " &mut self,", + " address: Address,", + " ) -> Result, ::Error> {", + " let acc = self.journaled_state.load_account_code(address)?;", + " if acc.is_empty() {", + " return Ok(Eip7702CodeLoad::new_not_delegated(B256::ZERO, acc.is_cold));", + " }", + " // SAFETY: Safe to unwrap as load_code will insert code if it is empty.", + " let code = acc.info.code.as_ref().unwrap();", + "", + " // If bytecode is EIP-7702 then we need to load the delegated account.", + " if let Bytecode::Eip7702(code) = code {", + " let address = code.address();", + " let is_cold = acc.is_cold;", + "", + " let delegated_account = self.journaled_state.load_account_code(address)?;", + "", + " let hash = if delegated_account.is_empty() {", + " B256::ZERO", + " } else if delegated_account.info.code.as_ref().unwrap().is_eof() {", + " EOF_MAGIC_HASH", + " } else {", + " delegated_account.info.code_hash", + " };", + "", + " return Ok(Eip7702CodeLoad::new(", + " StateLoad::new(hash, is_cold),", + " delegated_account.is_cold,", + " ));", + " }", + "", + " let hash = if code.is_eof() {", + " EOF_MAGIC_HASH", + " } else {", + " acc.info.code_hash", + " };", + "", + " Ok(Eip7702CodeLoad::new_not_delegated(hash, acc.is_cold))", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_empty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "acc" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "code", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "LocalVar": "code" + }, + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_bytecode::bytecode::Bytecode::Eip7702" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "address", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "eip7702", + "Eip7702Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "acc" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "delegated_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "hash", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_empty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "delegated_account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_eof", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "delegated_account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_bytecode", + "eof", + "EOF_MAGIC_HASH" + ] + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "delegated_account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "delegated_account" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "hash", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_eof", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_bytecode", + "eof", + "EOF_MAGIC_HASH" + ] + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "acc" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "host", + "Host" + ], + "trait_ty_params": [], + "items": [ + { + "name": "block_hash", + "snippet": [ + " fn block_hash(&mut self, requested_number: u64) -> Option {", + " let block_number = self.block().number();", + "", + " let Some(diff) = block_number.checked_sub(requested_number) else {", + " return Some(B256::ZERO);", + " };", + "", + " // blockhash should push zero if number is same as current block number.", + " if diff == 0 {", + " return Some(B256::ZERO);", + " }", + "", + " if diff <= BLOCK_HASH_HISTORY {", + " return self", + " .journaled_state", + " .db()", + " .block_hash(requested_number)", + " .map_err(|e| self.error = Err(e))", + " .ok();", + " }", + "", + " Some(B256::ZERO)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "requested_number", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "requested_number", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "requested_number" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "block_number", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "BLOCK" + } + }, + "trait_tys": [], + "method_name": "number", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "block", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "func": "checked_sub", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block_number" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "requested_number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "diff", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "diff" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.le" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "diff" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_primitives", + "constants", + "BLOCK_HASH_HISTORY" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "block_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "db", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "requested_number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account_delegated", + "snippet": [ + " fn load_account_delegated(&mut self, address: Address) -> Option {", + " self.journaled_state", + " .load_account_delegated(address)", + " .map_err(|e| self.error = Err(e))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "balance", + "snippet": [ + " fn balance(&mut self, address: Address) -> Option> {", + " self.journaled_state", + " .load_account(address)", + " .map_err(|e| self.error = Err(e))", + " .map(|acc| acc.map(|a| a.info.balance))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "map", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "acc", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "map", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "a", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "a" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code", + "snippet": [ + " fn code(&mut self, address: Address) -> Option> {", + " self.code(address).map_err(|e| self.error = Err(e)).ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code_hash", + "snippet": [ + " fn code_hash(&mut self, address: Address) -> Option> {", + " self.code_hash(address)", + " .map_err(|e| self.error = Err(e))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "func": "code_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + " fn sload(&mut self, address: Address, index: U256) -> Option> {", + " self.journaled_state", + " .sload(address, index)", + " .map_err(|e| self.error = Err(e))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "sload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + " fn sstore(", + " &mut self,", + " address: Address,", + " index: U256,", + " value: U256,", + " ) -> Option> {", + " self.journaled_state", + " .sstore(address, index, value)", + " .map_err(|e| self.error = Err(e))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "sstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + " fn tload(&mut self, address: Address, index: U256) -> U256 {", + " self.journaled_state.tload(address, index)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "tload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + " fn tstore(&mut self, address: Address, index: U256, value: U256) {", + " self.journaled_state.tstore(address, index, value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "tstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + " fn log(&mut self, log: Log) {", + " self.journaled_state.log(log);", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "log", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + " fn selfdestruct(", + " &mut self,", + " address: Address,", + " target: Address,", + " ) -> Option> {", + " self.journaled_state", + " .selfdestruct(address, target)", + " .map_err(|e| self.error = Err(e))", + " .ok()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + "Associated" + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + "Associated" + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + " type Cfg = CFG;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "CFG" + } + } + } + } + } + }, + { + "name": "cfg", + "snippet": [ + " fn cfg(&self) -> &Self::Cfg {", + " &self.cfg", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Journal", + "snippet": [ + " type Journal = JOURNAL;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + } + } + }, + { + "name": "journal", + "snippet": [ + " fn journal(&mut self) -> &mut Self::Journal {", + " &mut self.journaled_state", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "journal_ref", + "snippet": [ + " fn journal_ref(&self) -> &Self::Journal {", + " &self.journaled_state", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_database_interface", + "DatabaseGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Database", + "snippet": [ + " type Database = DB;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "DB" + } + } + } + } + } + }, + { + "name": "db", + "snippet": [ + " fn db(&mut self) -> &mut Self::Database {", + " self.journaled_state.db()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "db", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "db_ref", + "snippet": [ + " fn db_ref(&self) -> &Self::Database {", + " self.journaled_state.db_ref()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "JOURNAL" + } + }, + "trait_tys": [], + "method_name": "db_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "journaled_state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Error", + "snippet": [ + " type Error = EVMError;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + "Associated" + ] + } + } + } + } + } + }, + { + "name": "take_error", + "snippet": [ + " fn take_error(&mut self) -> Result<(), Self::Error> {", + " core::mem::replace(&mut self.error, Ok(())).map_err(EVMError::Database)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "func": "map_err", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + "Associated" + ] + } + }, + { + "Function": { + "args": [ + "Associated" + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + "Associated" + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "mem", + "replace" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "error" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.constructor_as_closure" + }, + "args": [ + { + "InternalString": "revm_context_interface::result::EVMError::Database" + } + ], + "kind": "Pure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + " type Transaction = TX;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "TX" + } + } + } + } + } + }, + { + "name": "tx", + "snippet": [ + " fn tx(&self) -> &Self::Transaction {", + " &self.tx", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_tx", + "snippet": [ + " fn set_tx(&mut self, tx: ::Transaction) {", + " self.tx = tx;", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "tx", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + " type Block = BLOCK;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "BLOCK" + } + } + } + } + } + }, + { + "name": "block", + "snippet": [ + " fn block(&self) -> &Self::Block {", + " &self.block", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/context.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "SPEC", + "DB", + "JOURNAL", + "CHAIN" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "JOURNAL" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_block", + "snippet": [ + " fn set_block(&mut self, block: ::Block) {", + " self.block = block;", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "context", + "Context" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "SPEC" + } + }, + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "JOURNAL" + } + }, + { + "Var": { + "name": "CHAIN" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "block", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::context::Context" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/context.v b/CoqOfRust/revm/translations/context/context.v new file mode 100644 index 000000000..a4a232240 --- /dev/null +++ b/CoqOfRust/revm/translations/context/context.v @@ -0,0 +1,5202 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module context. + (* StructRecord + { + name := "Context"; + const_params := []; + ty_params := [ "BLOCK"; "TX"; "CFG"; "DB"; "JOURNAL"; "CHAIN" ]; + fields := + [ + ("block", BLOCK); + ("tx", TX); + ("cfg", CFG); + ("journaled_state", JOURNAL); + ("chain", CHAIN); + ("error", Ty.apply (Ty.path "core::result::Result") [] [ Ty.tuple []; Ty.associated ]) + ]; + } *) + + Module Impl_core_clone_Clone_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_where_core_clone_Clone_BLOCK_where_core_clone_Clone_CFG_where_core_clone_Clone_CHAIN_where_core_clone_Clone_TX_where_core_clone_Clone_DB_where_core_clone_Clone_JOURNAL_where_core_clone_Clone_associated_type_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::context::Context") [] [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ]. + + (* #[derive_where(Clone, Debug; BLOCK, CFG, CHAIN, TX, DB, JOURNAL, ::Error)] *) + Definition clone + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "block" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "tx" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "cfg" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "journaled_state" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "chain" + |) in + let γ1_5 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "error" + |) in + let __field_block := M.alloc (| γ1_0 |) in + let __field_tx := M.alloc (| γ1_1 |) in + let __field_cfg := M.alloc (| γ1_2 |) in + let __field_journaled_state := M.alloc (| γ1_3 |) in + let __field_chain := M.alloc (| γ1_4 |) in + let __field_error := M.alloc (| γ1_5 |) in + M.alloc (| + Value.StructRecord + "revm_context::context::Context" + [ + ("block", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", BLOCK, [], "clone", [] |), + [ M.read (| __field_block |) ] + |)); + ("tx", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", TX, [], "clone", [] |), + [ M.read (| __field_tx |) ] + |)); + ("cfg", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", CFG, [], "clone", [] |), + [ M.read (| __field_cfg |) ] + |)); + ("journaled_state", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + JOURNAL, + [], + "clone", + [] + |), + [ M.read (| __field_journaled_state |) ] + |)); + ("chain", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", CHAIN, [], "clone", [] |), + [ M.read (| __field_chain |) ] + |)); + ("error", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.tuple []; Ty.associated ], + [], + "clone", + [] + |), + [ M.read (| __field_error |) ] + |)) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self BLOCK TX CFG DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone BLOCK TX CFG DB JOURNAL CHAIN)) ]. + End Impl_core_clone_Clone_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_where_core_clone_Clone_BLOCK_where_core_clone_Clone_CFG_where_core_clone_Clone_CHAIN_where_core_clone_Clone_TX_where_core_clone_Clone_DB_where_core_clone_Clone_JOURNAL_where_core_clone_Clone_associated_type_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + + Module Impl_core_fmt_Debug_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_where_core_fmt_Debug_BLOCK_where_core_fmt_Debug_CFG_where_core_fmt_Debug_CHAIN_where_core_fmt_Debug_TX_where_core_fmt_Debug_DB_where_core_fmt_Debug_JOURNAL_where_core_fmt_Debug_associated_type_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::context::Context") [] [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ]. + + (* #[derive_where(Clone, Debug; BLOCK, CFG, CHAIN, TX, DB, JOURNAL, ::Error)] *) + Definition fmt + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; __f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let __f := M.alloc (| __f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "block" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "tx" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "cfg" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "journaled_state" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "chain" + |) in + let γ1_5 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::context::Context", + "error" + |) in + let __field_block := M.alloc (| γ1_0 |) in + let __field_tx := M.alloc (| γ1_1 |) in + let __field_cfg := M.alloc (| γ1_2 |) in + let __field_journaled_state := M.alloc (| γ1_3 |) in + let __field_chain := M.alloc (| γ1_4 |) in + let __field_error := M.alloc (| γ1_5 |) in + let~ __builder := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct", + [] + |), + [ M.read (| __f |); M.read (| Value.String "Context" |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ __builder; M.read (| Value.String "block" |); M.read (| __field_block |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ __builder; M.read (| Value.String "tx" |); M.read (| __field_tx |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ __builder; M.read (| Value.String "cfg" |); M.read (| __field_cfg |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ + __builder; + M.read (| Value.String "journaled_state" |); + M.read (| __field_journaled_state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ __builder; M.read (| Value.String "chain" |); M.read (| __field_chain |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "field", + [] + |), + [ __builder; M.read (| Value.String "error" |); M.read (| __field_error |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::builders::DebugStruct", + "finish", + [] + |), + [ __builder ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self BLOCK TX CFG DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt BLOCK TX CFG DB JOURNAL CHAIN)) ]. + End Impl_core_fmt_Debug_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_where_core_fmt_Debug_BLOCK_where_core_fmt_Debug_CFG_where_core_fmt_Debug_CHAIN_where_core_fmt_Debug_TX_where_core_fmt_Debug_DB_where_core_fmt_Debug_JOURNAL_where_core_fmt_Debug_associated_type_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + + Module Impl_core_default_Default_for_revm_context_context_Context_revm_context_block_BlockEnv_revm_context_tx_TxEnv_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_revm_context_journaled_state_JournaledState_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_Tuple_. + Definition Self : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ + Ty.path "revm_context::block::BlockEnv"; + Ty.path "revm_context::tx::TxEnv"; + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]; + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ]; + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ] + ]; + Ty.tuple [] + ]. + + (* + fn default() -> Self { + Self::new(EmptyDB::new(), SpecId::LATEST) + } + *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ + Ty.path "revm_context::block::BlockEnv"; + Ty.path "revm_context::tx::TxEnv"; + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]; + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ]; + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ] + ]; + Ty.tuple [] + ], + "new", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ], + "new", + [] + |), + [] + |); + Value.StructTuple "revm_specification::hardfork::SpecId::LATEST" [] + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_context_Context_revm_context_block_BlockEnv_revm_context_tx_TxEnv_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_revm_context_journaled_state_JournaledState_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_Tuple_. + + Module Impl_revm_context_context_Context_revm_context_block_BlockEnv_revm_context_tx_TxEnv_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_revm_context_journaled_state_JournaledState_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_Tuple_. + Definition Self : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ + Ty.path "revm_context::block::BlockEnv"; + Ty.path "revm_context::tx::TxEnv"; + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]; + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ]; + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ] + ]; + Ty.tuple [] + ]. + + (* + pub fn builder() -> Self { + Self::new(EmptyDB::new(), SpecId::LATEST) + } + *) + Definition builder (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ + Ty.path "revm_context::block::BlockEnv"; + Ty.path "revm_context::tx::TxEnv"; + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]; + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ]; + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ] + ]; + Ty.tuple [] + ], + "new", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_database_interface::empty_db::EmptyDBTyped") + [] + [ Ty.path "core::convert::Infallible" ], + "new", + [] + |), + [] + |); + Value.StructTuple "revm_specification::hardfork::SpecId::LATEST" [] + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_builder : M.IsAssociatedFunction Self "builder" builder. + End Impl_revm_context_context_Context_revm_context_block_BlockEnv_revm_context_tx_TxEnv_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_revm_context_journaled_state_JournaledState_revm_database_interface_empty_db_EmptyDBTyped_core_convert_Infallible_Tuple_. + + Module Impl_revm_context_context_Context_BLOCK_TX_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ + BLOCK; + TX; + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ]; + DB; + JOURNAL; + CHAIN + ]. + + (* + pub fn new(db: DB, spec: SpecId) -> Self { + let mut journaled_state = JOURNAL::new(db); + journaled_state.set_spec_id(spec); + Self { + tx: TX::default(), + block: BLOCK::default(), + cfg: CfgEnv { + spec, + ..Default::default() + }, + journaled_state, + chain: Default::default(), + error: Ok(()), + } + } + *) + Definition new + (BLOCK TX DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ db; spec ] => + ltac:(M.monadic + (let db := M.alloc (| db |) in + let spec := M.alloc (| spec |) in + M.read (| + let~ journaled_state := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "new", + [] + |), + [ M.read (| db |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "set_spec_id", + [] + |), + [ journaled_state; M.read (| spec |) ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.call_closure (| + M.get_trait_method (| "core::default::Default", TX, [], "default", [] |), + [] + |)); + ("block", + M.call_closure (| + M.get_trait_method (| "core::default::Default", BLOCK, [], "default", [] |), + [] + |)); + ("cfg", + M.struct_record_update + (M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context::cfg::CfgEnv") + [] + [ Ty.path "revm_specification::hardfork::SpecId" ], + [], + "default", + [] + |), + [] + |)) + [ ("spec", M.read (| spec |)) ]); + ("journaled_state", M.read (| journaled_state |)); + ("chain", + M.call_closure (| + M.get_trait_method (| "core::default::Default", CHAIN, [], "default", [] |), + [] + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : + forall (BLOCK TX DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction (Self BLOCK TX DB JOURNAL CHAIN) "new" (new BLOCK TX DB JOURNAL CHAIN). + End Impl_revm_context_context_Context_BLOCK_TX_revm_context_cfg_CfgEnv_revm_specification_hardfork_SpecId_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::context::Context") [] [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ]. + + (* + pub fn code( + &mut self, + address: Address, + ) -> Result, ::Error> { + let a = self.journaled_state.load_account_code(address)?; + // SAFETY: Safe to unwrap as load_code will insert code if it is empty. + let code = a.info.code.as_ref().unwrap(); + if code.is_eof() { + return Ok(Eip7702CodeLoad::new_not_delegated( + EOF_MAGIC_BYTES.clone(), + a.is_cold, + )); + } + + if let Bytecode::Eip7702(code) = code { + let address = code.address(); + let is_cold = a.is_cold; + + let delegated_account = self.journaled_state.load_account_code(address)?; + + // SAFETY: Safe to unwrap as load_code will insert code if it is empty. + let delegated_code = delegated_account.info.code.as_ref().unwrap(); + + let bytes = if delegated_code.is_eof() { + EOF_MAGIC_BYTES.clone() + } else { + delegated_code.original_bytes() + }; + + return Ok(Eip7702CodeLoad::new( + StateLoad::new(bytes, is_cold), + delegated_account.is_cold, + )); + } + + Ok(Eip7702CodeLoad::new_not_delegated( + code.original_bytes(), + a.is_cold, + )) + } + *) + Definition code + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ a := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account_code", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ code := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ], + "as_ref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ a ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |) + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "is_eof", + [] + |), + [ M.read (| code |) ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + "new_not_delegated", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ + M.read (| + M.get_constant (| + "revm_bytecode::eof::EOF_MAGIC_BYTES" + |) + |) + ] + |); + M.read (| + M.SubPointer.get_struct_record_field (| + a, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := code in + let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_bytecode::bytecode::Bytecode::Eip7702", + 0 + |) in + let code := M.alloc (| γ1_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ address := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::eip7702::Eip7702Bytecode", + "address", + [] + |), + [ M.read (| code |) ] + |) + |) in + let~ is_cold := + M.copy (| + M.SubPointer.get_struct_record_field (| + a, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) in + let~ delegated_account := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account_code", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.path + "alloy_primitives::bytes_::Bytes" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ delegated_code := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ], + "as_ref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ delegated_account ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |) + ] + |) + ] + |) + |) in + let~ bytes := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "is_eof", + [] + |), + [ M.read (| delegated_code |) ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ + M.read (| + M.get_constant (| + "revm_bytecode::eof::EOF_MAGIC_BYTES" + |) + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "original_bytes", + [] + |), + [ M.read (| delegated_code |) ] + |) + |))) + ] + |) + |) in + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + "new", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + "new", + [] + |), + [ M.read (| bytes |); M.read (| is_cold |) ] + |); + M.read (| + M.SubPointer.get_struct_record_field (| + delegated_account, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + "new_not_delegated", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "original_bytes", + [] + |), + [ M.read (| code |) ] + |); + M.read (| + M.SubPointer.get_struct_record_field (| + a, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_code : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "code" + (code BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_new_journal>( + self, + mut journal: OJOURNAL, + ) -> Context { + journal.set_spec_id(self.cfg.spec().into()); + Context { + tx: self.tx, + block: self.block, + cfg: self.cfg, + journaled_state: journal, + chain: self.chain, + error: Ok(()), + } + } + *) + Definition with_new_journal + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ OJOURNAL ], [ self; journal ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let journal := M.alloc (| journal |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + OJOURNAL, + [], + "set_spec_id", + [] + |), + [ + journal; + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ Ty.path "revm_specification::hardfork::SpecId" ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + CFG, + [], + "spec", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + ] + |) + ] + |) + ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "tx" + |) + |)); + ("block", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "block" + |) + |)); + ("cfg", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + |)); + ("journaled_state", M.read (| journal |)); + ("chain", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "chain" + |) + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_new_journal : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_new_journal" + (with_new_journal BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_db( + self, + db: ODB, + ) -> Context, CHAIN> { + let spec = self.cfg.spec().into(); + let mut journaled_state = JournaledState::new(spec, db); + journaled_state.set_spec_id(spec); + Context { + tx: self.tx, + block: self.block, + cfg: self.cfg, + journaled_state, + chain: self.chain, + error: Ok(()), + } + } + *) + Definition with_db + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ ODB ], [ self; db ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let db := M.alloc (| db |) in + M.read (| + let~ spec := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ Ty.path "revm_specification::hardfork::SpecId" ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + CFG, + [], + "spec", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + ] + |) + ] + |) + |) in + let~ journaled_state := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ ODB ], + "new", + [] + |), + [ M.read (| spec |); M.read (| db |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ ODB ], + "set_spec_id", + [] + |), + [ journaled_state; M.read (| spec |) ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "tx" + |) + |)); + ("block", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "block" + |) + |)); + ("cfg", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + |)); + ("journaled_state", M.read (| journaled_state |)); + ("chain", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "chain" + |) + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_db : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_db" + (with_db BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_block(self, block: OB) -> Context { + Context { + tx: self.tx, + block, + cfg: self.cfg, + journaled_state: self.journaled_state, + chain: self.chain, + error: Ok(()), + } + } + *) + Definition with_block + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ OB ], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "tx" + |) + |)); + ("block", M.read (| block |)); + ("cfg", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + |)); + ("journaled_state", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |) + |)); + ("chain", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "chain" + |) + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_block : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_block" + (with_block BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_tx( + self, + tx: OTX, + ) -> Context { + Context { + tx, + block: self.block, + cfg: self.cfg, + journaled_state: self.journaled_state, + chain: self.chain, + error: Ok(()), + } + } + *) + Definition with_tx + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ OTX ], [ self; tx ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let tx := M.alloc (| tx |) in + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", M.read (| tx |)); + ("block", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "block" + |) + |)); + ("cfg", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + |)); + ("journaled_state", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |) + |)); + ("chain", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "chain" + |) + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_tx : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_tx" + (with_tx BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_chain(self, chain: OC) -> Context { + Context { + tx: self.tx, + block: self.block, + cfg: self.cfg, + journaled_state: self.journaled_state, + chain, + error: Ok(()), + } + } + *) + Definition with_chain + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ OC ], [ self; chain ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let chain := M.alloc (| chain |) in + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "tx" + |) + |)); + ("block", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "block" + |) + |)); + ("cfg", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + |)); + ("journaled_state", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |) + |)); + ("chain", M.read (| chain |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_chain : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_chain" + (with_chain BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn with_cfg( + mut self, + cfg: OCFG, + ) -> Context { + self.journaled_state.set_spec_id(cfg.spec().into()); + Context { + tx: self.tx, + block: self.block, + cfg, + journaled_state: self.journaled_state, + chain: self.chain, + error: Ok(()), + } + } + *) + Definition with_cfg + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ OCFG ], [ self; cfg ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let cfg := M.alloc (| cfg |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "set_spec_id", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |); + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ Ty.path "revm_specification::hardfork::SpecId" ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + OCFG, + [], + "spec", + [] + |), + [ cfg ] + |) + ] + |) + ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context::context::Context" + [ + ("tx", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "tx" + |) + |)); + ("block", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "block" + |) + |)); + ("cfg", M.read (| cfg |)); + ("journaled_state", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |) + |)); + ("chain", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "chain" + |) + |)); + ("error", Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_with_cfg : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "with_cfg" + (with_cfg BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_cfg_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut CFG), + { + f(&mut self.cfg); + self.journaled_state.set_spec_id(self.cfg.spec().into()); + self + } + *) + Definition modify_cfg_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ CFG ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + ] + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "set_spec_id", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "journaled_state" + |); + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ Ty.path "revm_specification::hardfork::SpecId" ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + CFG, + [], + "spec", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + self, + "revm_context::context::Context", + "cfg" + |) + ] + |) + ] + |) + ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_cfg_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_cfg_chained" + (modify_cfg_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_block_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut BLOCK), + { + self.modify_block(f); + self + } + *) + Definition modify_block_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "modify_block", + [ F ] + |), + [ self; M.read (| f |) ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_block_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_block_chained" + (modify_block_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_tx_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut TX), + { + self.modify_tx(f); + self + } + *) + Definition modify_tx_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "modify_tx", + [ F ] + |), + [ self; M.read (| f |) ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_tx_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_tx_chained" + (modify_tx_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_chain_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut CHAIN), + { + self.modify_chain(f); + self + } + *) + Definition modify_chain_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "modify_chain", + [ F ] + |), + [ self; M.read (| f |) ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_chain_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_chain_chained" + (modify_chain_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_db_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut DB), + { + self.modify_db(f); + self + } + *) + Definition modify_db_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "modify_db", + [ F ] + |), + [ self; M.read (| f |) ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_db_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_db_chained" + (modify_db_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_journal_chained(mut self, f: F) -> Self + where + F: FnOnce(&mut JOURNAL), + { + self.modify_journal(f); + self + } + *) + Definition modify_journal_chained + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "modify_journal", + [ F ] + |), + [ self; M.read (| f |) ] + |) + |) in + self + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_journal_chained : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_journal_chained" + (modify_journal_chained BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_block(&mut self, f: F) + where + F: FnOnce(&mut BLOCK), + { + f(&mut self.block); + } + *) + Definition modify_block + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ BLOCK ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "block" + |) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_block : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_block" + (modify_block BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_tx(&mut self, f: F) + where + F: FnOnce(&mut TX), + { + f(&mut self.tx); + } + *) + Definition modify_tx + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ TX ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "tx" + |) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_tx : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_tx" + (modify_tx BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_cfg(&mut self, f: F) + where + F: FnOnce(&mut CFG), + { + f(&mut self.cfg); + self.journaled_state.set_spec_id(self.cfg.spec().into()); + } + *) + Definition modify_cfg + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ CFG ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "cfg" + |) + ] + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "set_spec_id", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ Ty.path "revm_specification::hardfork::SpecId" ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + CFG, + [], + "spec", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "cfg" + |) + ] + |) + ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_cfg : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_cfg" + (modify_cfg BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_chain(&mut self, f: F) + where + F: FnOnce(&mut CHAIN), + { + f(&mut self.chain); + } + *) + Definition modify_chain + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ CHAIN ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "chain" + |) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_chain : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_chain" + (modify_chain BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_db(&mut self, f: F) + where + F: FnOnce(&mut DB), + { + f(self.journaled_state.db()); + } + *) + Definition modify_db + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ DB ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "db", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |) + ] + |) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_db : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_db" + (modify_db BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn modify_journal(&mut self, f: F) + where + F: FnOnce(&mut JOURNAL), + { + f(&mut self.journaled_state); + } + *) + Definition modify_journal + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [ F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ Ty.apply (Ty.path "&mut") [] [ JOURNAL ] ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_modify_journal : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "modify_journal" + (modify_journal BLOCK TX CFG DB JOURNAL CHAIN). + + (* + pub fn code_hash( + &mut self, + address: Address, + ) -> Result, ::Error> { + let acc = self.journaled_state.load_account_code(address)?; + if acc.is_empty() { + return Ok(Eip7702CodeLoad::new_not_delegated(B256::ZERO, acc.is_cold)); + } + // SAFETY: Safe to unwrap as load_code will insert code if it is empty. + let code = acc.info.code.as_ref().unwrap(); + + // If bytecode is EIP-7702 then we need to load the delegated account. + if let Bytecode::Eip7702(code) = code { + let address = code.address(); + let is_cold = acc.is_cold; + + let delegated_account = self.journaled_state.load_account_code(address)?; + + let hash = if delegated_account.is_empty() { + B256::ZERO + } else if delegated_account.info.code.as_ref().unwrap().is_eof() { + EOF_MAGIC_HASH + } else { + delegated_account.info.code_hash + }; + + return Ok(Eip7702CodeLoad::new( + StateLoad::new(hash, is_cold), + delegated_account.is_cold, + )); + } + + let hash = if code.is_eof() { + EOF_MAGIC_HASH + } else { + acc.info.code_hash + }; + + Ok(Eip7702CodeLoad::new_not_delegated(hash, acc.is_cold)) + } + *) + Definition code_hash + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ acc := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account_code", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_empty", + [] + |), + [ + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ acc ] + |) + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "new_not_delegated", + [] + |), + [ + M.read (| + M.get_constant (| + "alloy_primitives::bits::fixed::ZERO" + |) + |); + M.read (| + M.SubPointer.get_struct_record_field (| + acc, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ code := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ], + "as_ref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ acc ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |) + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := code in + let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_bytecode::bytecode::Bytecode::Eip7702", + 0 + |) in + let code := M.alloc (| γ1_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ address := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::eip7702::Eip7702Bytecode", + "address", + [] + |), + [ M.read (| code |) ] + |) + |) in + let~ is_cold := + M.copy (| + M.SubPointer.get_struct_record_field (| + acc, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) in + let~ delegated_account := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account_code", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ + Value.Integer + IntegerKind.Usize + 32 + ] + [] + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ hash := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_empty", + [] + |), + [ + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ delegated_account ] + |) + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.get_constant (| + "alloy_primitives::bits::fixed::ZERO" + |))); + fun γ => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_bytecode::bytecode::Bytecode", + "is_eof", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_bytecode::bytecode::Bytecode" + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "core::option::Option") + [] + [ + Ty.path + "revm_bytecode::bytecode::Bytecode" + ], + "as_ref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path + "&mut") + [] + [ + Ty.path + "revm_state::Account" + ] + ], + [], + "deref", + [] + |), + [ delegated_account ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |) + ] + |) + ] + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.get_constant (| + "revm_bytecode::eof::EOF_MAGIC_HASH" + |))); + fun γ => + ltac:(M.monadic + (M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" + ] + ], + [], + "deref", + [] + |), + [ delegated_account ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code_hash" + |))) + ] + |))) + ] + |) + |) in + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "new", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "new", + [] + |), + [ M.read (| hash |); M.read (| is_cold |) ] + |); + M.read (| + M.SubPointer.get_struct_record_field (| + delegated_account, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ hash := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "is_eof", + [] + |), + [ M.read (| code |) ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.get_constant (| "revm_bytecode::eof::EOF_MAGIC_HASH" |))); + fun γ => + ltac:(M.monadic + (M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ acc ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code_hash" + |))) + ] + |) + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "new_not_delegated", + [] + |), + [ + M.read (| hash |); + M.read (| + M.SubPointer.get_struct_record_field (| + acc, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_code_hash : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsAssociatedFunction + (Self BLOCK TX CFG DB JOURNAL CHAIN) + "code_hash" + (code_hash BLOCK TX CFG DB JOURNAL CHAIN). + End Impl_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_host_Host_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::context::Context") [] [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ]. + + (* + fn block_hash(&mut self, requested_number: u64) -> Option { + let block_number = self.block().number(); + + let Some(diff) = block_number.checked_sub(requested_number) else { + return Some(B256::ZERO); + }; + + // blockhash should push zero if number is same as current block number. + if diff == 0 { + return Some(B256::ZERO); + } + + if diff <= BLOCK_HASH_HISTORY { + return self + .journaled_state + .db() + .block_hash(requested_number) + .map_err(|e| self.error = Err(e)) + .ok(); + } + + Some(B256::ZERO) + } + *) + Definition block_hash + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; requested_number ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let requested_number := M.alloc (| requested_number |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ block_number := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + BLOCK, + [], + "number", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockGetter", + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ] + ], + [], + "block", + [] + |), + [ self ] + |) + ] + |) + |) in + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| Ty.path "u64", "checked_sub", [] |), + [ M.read (| block_number |); M.read (| requested_number |) ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let diff := M.copy (| γ0_0 |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + BinOp.eq (| + M.read (| diff |), + Value.Integer IntegerKind.U64 0 + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + Value.StructTuple + "core::option::Option::Some" + [ + M.read (| + M.get_constant (| + "alloy_primitives::bits::fixed::ZERO" + |) + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + BinOp.le (| + M.read (| diff |), + M.read (| + M.get_constant (| + "revm_primitives::constants::BLOCK_HASH_HISTORY" + |) + |) + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.associated + ], + "map_err", + [ + Ty.tuple []; + Ty.function + [ Ty.tuple [ Ty.associated ] ] + (Ty.tuple []) + ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "block_hash", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "db", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |) + ] + |); + M.read (| requested_number |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => + M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |) + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.read (| + M.get_constant (| "alloy_primitives::bits::fixed::ZERO" |) + |) + ] + |))) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn load_account_delegated(&mut self, address: Address) -> Option { + self.journaled_state + .load_account_delegated(address) + .map_err(|e| self.error = Err(e)) + .ok() + } + *) + Definition load_account_delegated + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "revm_context_interface::journaled_state::AccountLoad"; Ty.tuple [] ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "revm_context_interface::journaled_state::AccountLoad"; Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account_delegated", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn balance(&mut self, address: Address) -> Option> { + self.journaled_state + .load_account(address) + .map_err(|e| self.error = Err(e)) + .map(|acc| acc.map(|a| a.info.balance)) + .ok() + } + *) + Definition balance + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ]; + Ty.tuple [] + ], + "map", + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]; + Ty.function + [ + Ty.tuple + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ] + ] + ] + (Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [] + ]) + ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "load_account", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let acc := M.copy (| γ |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "map", + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.function + [ + Ty.tuple + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ] + ] + (Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []) + ] + |), + [ + M.read (| acc |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let a := M.copy (| γ |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| a |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn code(&mut self, address: Address) -> Option> { + self.code(address).map_err(|e| self.error = Err(e)).ok() + } + *) + Definition code + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "code", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn code_hash(&mut self, address: Address) -> Option> { + self.code_hash(address) + .map_err(|e| self.error = Err(e)) + .ok() + } + *) + Definition code_hash + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ], + "code_hash", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sload(&mut self, address: Address, index: U256) -> Option> { + self.journaled_state + .sload(address, index) + .map_err(|e| self.error = Err(e)) + .ok() + } + *) + Definition sload + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "sload", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |); + M.read (| index |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sstore( + &mut self, + address: Address, + index: U256, + value: U256, + ) -> Option> { + self.journaled_state + .sstore(address, index, value) + .map_err(|e| self.error = Err(e)) + .ok() + } + *) + Definition sstore + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SStoreResult" ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SStoreResult" ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "sstore", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tload(&mut self, address: Address, index: U256) -> U256 { + self.journaled_state.tload(address, index) + } + *) + Definition tload + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "tload", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |); + M.read (| index |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tstore(&mut self, address: Address, index: U256, value: U256) { + self.journaled_state.tstore(address, index, value) + } + *) + Definition tstore + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "tstore", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn log(&mut self, log: Log) { + self.journaled_state.log(log); + } + *) + Definition log + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "log", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| log |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn selfdestruct( + &mut self, + address: Address, + target: Address, + ) -> Option> { + self.journaled_state + .selfdestruct(address, target) + .map_err(|e| self.error = Err(e)) + .ok() + } + *) + Definition selfdestruct + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; address; target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let target := M.alloc (| target |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SelfDestructResult" ]; + Ty.tuple [] + ], + "ok", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SelfDestructResult" ]; + Ty.associated + ], + "map_err", + [ Ty.tuple []; Ty.function [ Ty.tuple [ Ty.associated ] ] (Ty.tuple []) ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "selfdestruct", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |); + M.read (| address |); + M.read (| target |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let e := M.copy (| γ |) in + M.read (| + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |), + Value.StructTuple + "core::result::Result::Err" + [ M.read (| e |) ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::host::Host" + (Self BLOCK TX CFG DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("block_hash", InstanceField.Method (block_hash BLOCK TX CFG DB JOURNAL CHAIN)); + ("load_account_delegated", + InstanceField.Method (load_account_delegated BLOCK TX CFG DB JOURNAL CHAIN)); + ("balance", InstanceField.Method (balance BLOCK TX CFG DB JOURNAL CHAIN)); + ("code", InstanceField.Method (code BLOCK TX CFG DB JOURNAL CHAIN)); + ("code_hash", InstanceField.Method (code_hash BLOCK TX CFG DB JOURNAL CHAIN)); + ("sload", InstanceField.Method (sload BLOCK TX CFG DB JOURNAL CHAIN)); + ("sstore", InstanceField.Method (sstore BLOCK TX CFG DB JOURNAL CHAIN)); + ("tload", InstanceField.Method (tload BLOCK TX CFG DB JOURNAL CHAIN)); + ("tstore", InstanceField.Method (tstore BLOCK TX CFG DB JOURNAL CHAIN)); + ("log", InstanceField.Method (log BLOCK TX CFG DB JOURNAL CHAIN)); + ("selfdestruct", InstanceField.Method (selfdestruct BLOCK TX CFG DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_host_Host_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_Cfg_CFG_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::context::Context") [] [ BLOCK; TX; CFG; DB; JOURNAL; CHAIN ]. + + (* type Cfg = CFG; *) + Definition _Cfg (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) : Ty.t := CFG. + + (* + fn cfg(&self) -> &Self::Cfg { + &self.cfg + } + *) + Definition cfg + (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "cfg" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self BLOCK TX CFG DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Cfg", InstanceField.Ty (_Cfg BLOCK TX CFG DB JOURNAL CHAIN)); + ("cfg", InstanceField.Method (cfg BLOCK TX CFG DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_Cfg_CFG_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_CFG_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* type Journal = JOURNAL; *) + Definition _Journal (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := JOURNAL. + + (* + fn journal(&mut self) -> &mut Self::Journal { + &mut self.journaled_state + } + *) + Definition journal + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn journal_ref(&self) -> &Self::Journal { + &self.journaled_state + } + *) + Definition journal_ref + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::journaled_state::JournalGetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Journal", InstanceField.Ty (_Journal BLOCK TX SPEC DB JOURNAL CHAIN)); + ("journal", InstanceField.Method (journal BLOCK TX SPEC DB JOURNAL CHAIN)); + ("journal_ref", InstanceField.Method (journal_ref BLOCK TX SPEC DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_database_interface_DatabaseGetter_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* type Database = DB; *) + Definition _Database (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := DB. + + (* + fn db(&mut self) -> &mut Self::Database { + self.journaled_state.db() + } + *) + Definition db + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "db", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn db_ref(&self) -> &Self::Database { + self.journaled_state.db_ref() + } + *) + Definition db_ref + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + JOURNAL, + [], + "db_ref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "journaled_state" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_database_interface::DatabaseGetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Database", InstanceField.Ty (_Database BLOCK TX SPEC DB JOURNAL CHAIN)); + ("db", InstanceField.Method (db BLOCK TX SPEC DB JOURNAL CHAIN)); + ("db_ref", InstanceField.Method (db_ref BLOCK TX SPEC DB JOURNAL CHAIN)) + ]. + End Impl_revm_database_interface_DatabaseGetter_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* type Error = EVMError; *) + Definition _Error (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ Ty.associated; Ty.associated ]. + + (* + fn take_error(&mut self) -> Result<(), Self::Error> { + core::mem::replace(&mut self.error, Ok(())).map_err(EVMError::Database) + } + *) + Definition take_error + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "core::result::Result") [] [ Ty.tuple []; Ty.associated ], + "map_err", + [ + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ Ty.associated; Ty.associated ]; + Ty.function + [ Ty.associated ] + (Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ Ty.associated; Ty.associated ]) + ] + |), + [ + M.call_closure (| + M.get_function (| + "core::mem::replace", + [ Ty.apply (Ty.path "core::result::Result") [] [ Ty.tuple []; Ty.associated ] ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "error" + |); + Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] + ] + |); + M.constructor_as_closure "revm_context_interface::result::EVMError::Database" + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::errors::ErrorGetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Error", InstanceField.Ty (_Error BLOCK TX SPEC DB JOURNAL CHAIN)); + ("take_error", InstanceField.Method (take_error BLOCK TX SPEC DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* type Transaction = TX; *) + Definition _Transaction (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := TX. + + (* + fn tx(&self) -> &Self::Transaction { + &self.tx + } + *) + Definition tx + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "tx" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Transaction", InstanceField.Ty (_Transaction BLOCK TX SPEC DB JOURNAL CHAIN)); + ("tx", InstanceField.Method (tx BLOCK TX SPEC DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* + fn set_tx(&mut self, tx: ::Transaction) { + self.tx = tx; + } + *) + Definition set_tx + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; tx ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let tx := M.alloc (| tx |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "tx" + |), + M.read (| tx |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionSetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) [ ("set_tx", InstanceField.Method (set_tx BLOCK TX SPEC DB JOURNAL CHAIN)) ]. + End Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_Transaction_TX_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* type Block = BLOCK; *) + Definition _Block (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := BLOCK. + + (* + fn block(&self) -> &Self::Block { + &self.block + } + *) + Definition block + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "block" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Block", InstanceField.Ty (_Block BLOCK TX SPEC DB JOURNAL CHAIN)); + ("block", InstanceField.Method (block BLOCK TX SPEC DB JOURNAL CHAIN)) + ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + + Module Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_Block_BLOCK_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. + Definition Self (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context::context::Context") + [] + [ BLOCK; TX; SPEC; DB; JOURNAL; CHAIN ]. + + (* + fn set_block(&mut self, block: ::Block) { + self.block = block; + } + *) + Definition set_block + (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX SPEC DB JOURNAL CHAIN in + match ε, τ, α with + | [], [], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::context::Context", + "block" + |), + M.read (| block |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX SPEC DB JOURNAL CHAIN : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockSetter" + (Self BLOCK TX SPEC DB JOURNAL CHAIN) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("set_block", InstanceField.Method (set_block BLOCK TX SPEC DB JOURNAL CHAIN)) ]. + End Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_Block_BLOCK_where_revm_database_interface_Database_DB_where_revm_context_interface_journaled_state_Journal_JOURNAL_for_revm_context_context_Context_BLOCK_TX_SPEC_DB_JOURNAL_CHAIN. +End context. diff --git a/CoqOfRust/revm/translations/context/interface/block.json b/CoqOfRust/revm/translations/context/interface/block.json new file mode 100644 index 000000000..da5267f4d --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/block.json @@ -0,0 +1,9583 @@ +[ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "block", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Trait": { + "name": "Block", + "path": [ + "revm_context_interface", + "block", + "Block" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "number", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "beneficiary", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "timestamp", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "gas_limit", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "basefee", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "difficulty", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + } + } + } + } + ], + [ + "prevrandao", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "blob_excess_gas_and_price", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "blob_gasprice", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "map", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "a", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "a" + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "blob_gasprice" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + ], + [ + "blob_excess_gas", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "map", + "generic_tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "a", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "a" + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "Block" + ], + "trait_ty_params": [], + "items": [ + { + "name": "number", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "number", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "beneficiary", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "beneficiary", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "timestamp", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "timestamp", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "basefee", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "basefee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "difficulty", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "difficulty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "prevrandao", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "prevrandao", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas_and_price", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_gasprice", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_gasprice", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "Block" + ], + "trait_ty_params": [], + "items": [ + { + "name": "number", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "number", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "beneficiary", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "beneficiary", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "timestamp", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "timestamp", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "basefee", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "basefee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "difficulty", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "difficulty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "prevrandao", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "prevrandao", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas_and_price", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_gasprice", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_gasprice", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "Block" + ], + "trait_ty_params": [], + "items": [ + { + "name": "number", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "number", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "beneficiary", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "beneficiary", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "timestamp", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "timestamp", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "basefee", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "basefee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "difficulty", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "difficulty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "prevrandao", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "prevrandao", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas_and_price", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_gasprice", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_gasprice", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "Block" + ], + "trait_ty_params": [], + "items": [ + { + "name": "number", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "number", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "beneficiary", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "beneficiary", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "timestamp", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "timestamp", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "basefee", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "basefee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "difficulty", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "difficulty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "prevrandao", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "prevrandao", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas_and_price", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas_and_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_gasprice", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_gasprice", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_excess_gas", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "Block" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_excess_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Trait": { + "name": "BlockGetter", + "path": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Block", + { + "Type": [] + } + ], + [ + "block", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "block", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "Trait": { + "name": "BlockSetter", + "path": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "set_block", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + "Associated" + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_block", + "snippet": [ + " fn set_block(&mut self, block: ::Block) {", + " (**self).set_block(block)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "block", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "set_block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_block", + "snippet": [ + " fn set_block(&mut self, block: ::Block) {", + " (**self).set_block(block)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "block", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "block", + "BlockSetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "set_block", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/block.v b/CoqOfRust/revm/translations/context/interface/block.v new file mode 100644 index 000000000..52667d69f --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/block.v @@ -0,0 +1,1404 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module block. + (* Trait *) + Module Block. + Definition blob_gasprice + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ], + "map", + [ + Ty.path "u128"; + Ty.function + [ + Ty.tuple + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ] + ] + (Ty.path "u128") + ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + Self, + [], + "blob_excess_gas_and_price", + [] + |), + [ M.read (| self |) ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let a := M.copy (| γ |) in + M.read (| + M.SubPointer.get_struct_record_field (| + a, + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "blob_gasprice" + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_blob_gasprice : + M.IsProvidedMethod "revm_context_interface::block::Block" "blob_gasprice" blob_gasprice. + Definition blob_excess_gas + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ], + "map", + [ + Ty.path "u64"; + Ty.function + [ + Ty.tuple + [ Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice" ] + ] + (Ty.path "u64") + ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + Self, + [], + "blob_excess_gas_and_price", + [] + |), + [ M.read (| self |) ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let a := M.copy (| γ |) in + M.read (| + M.SubPointer.get_struct_record_field (| + a, + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "excess_blob_gas" + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_blob_excess_gas : + M.IsProvidedMethod "revm_context_interface::block::Block" "blob_excess_gas" blob_excess_gas. + End Block. + + Module underscore. + Module Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition number (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "number", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition beneficiary (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "beneficiary", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition timestamp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "timestamp", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "gas_limit", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition basefee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "basefee", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition difficulty (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "difficulty", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition prevrandao (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "prevrandao", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas_and_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas_and_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_gasprice + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_gasprice", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::Block" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("number", InstanceField.Method (number T)); + ("beneficiary", InstanceField.Method (beneficiary T)); + ("timestamp", InstanceField.Method (timestamp T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("basefee", InstanceField.Method (basefee T)); + ("difficulty", InstanceField.Method (difficulty T)); + ("prevrandao", InstanceField.Method (prevrandao T)); + ("blob_excess_gas_and_price", InstanceField.Method (blob_excess_gas_and_price T)); + ("blob_gasprice", InstanceField.Method (blob_gasprice T)); + ("blob_excess_gas", InstanceField.Method (blob_excess_gas T)) + ]. + End Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition number (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "number", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition beneficiary (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "beneficiary", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition timestamp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "timestamp", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "gas_limit", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition basefee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "basefee", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition difficulty (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "difficulty", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition prevrandao (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "prevrandao", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas_and_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas_and_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_gasprice + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_gasprice", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::Block" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("number", InstanceField.Method (number T)); + ("beneficiary", InstanceField.Method (beneficiary T)); + ("timestamp", InstanceField.Method (timestamp T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("basefee", InstanceField.Method (basefee T)); + ("difficulty", InstanceField.Method (difficulty T)); + ("prevrandao", InstanceField.Method (prevrandao T)); + ("blob_excess_gas_and_price", InstanceField.Method (blob_excess_gas_and_price T)); + ("blob_gasprice", InstanceField.Method (blob_gasprice T)); + ("blob_excess_gas", InstanceField.Method (blob_excess_gas T)) + ]. + End Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition number (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "number", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition beneficiary (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "beneficiary", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition timestamp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "timestamp", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "gas_limit", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition basefee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "basefee", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition difficulty (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "difficulty", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition prevrandao (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "prevrandao", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas_and_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas_and_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_gasprice + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_gasprice", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::Block" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("number", InstanceField.Method (number T)); + ("beneficiary", InstanceField.Method (beneficiary T)); + ("timestamp", InstanceField.Method (timestamp T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("basefee", InstanceField.Method (basefee T)); + ("difficulty", InstanceField.Method (difficulty T)); + ("prevrandao", InstanceField.Method (prevrandao T)); + ("blob_excess_gas_and_price", InstanceField.Method (blob_excess_gas_and_price T)); + ("blob_gasprice", InstanceField.Method (blob_gasprice T)); + ("blob_excess_gas", InstanceField.Method (blob_excess_gas T)) + ]. + End Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition number (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "number", [] |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition beneficiary (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "beneficiary", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition timestamp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "timestamp", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "gas_limit", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition basefee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::block::Block", T, [], "basefee", [] |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition difficulty (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "difficulty", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition prevrandao (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "prevrandao", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas_and_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas_and_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_gasprice + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_gasprice", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition blob_excess_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::Block", + T, + [], + "blob_excess_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::Block" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("number", InstanceField.Method (number T)); + ("beneficiary", InstanceField.Method (beneficiary T)); + ("timestamp", InstanceField.Method (timestamp T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("basefee", InstanceField.Method (basefee T)); + ("difficulty", InstanceField.Method (difficulty T)); + ("prevrandao", InstanceField.Method (prevrandao T)); + ("blob_excess_gas_and_price", InstanceField.Method (blob_excess_gas_and_price T)); + ("blob_gasprice", InstanceField.Method (blob_gasprice T)); + ("blob_excess_gas", InstanceField.Method (blob_excess_gas T)) + ]. + End Impl_revm_context_interface_block_Block_where_revm_context_interface_block_Block_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Block (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockGetter", + T, + [], + "block", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Block", InstanceField.Ty (_Block T)); ("block", InstanceField.Method (block T)) ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Block (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockGetter", + T, + [], + "block", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Block", InstanceField.Ty (_Block T)); ("block", InstanceField.Method (block T)) ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Block (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockGetter", + T, + [], + "block", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Block", InstanceField.Ty (_Block T)); ("block", InstanceField.Method (block T)) ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Block (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockGetter", + T, + [], + "block", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Block", InstanceField.Ty (_Block T)); ("block", InstanceField.Method (block T)) ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_BlockGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + End underscore. + + + + + (* Trait *) + (* Empty module 'BlockGetter' *) + + + + + + (* Trait *) + (* Empty module 'BlockSetter' *) + + Module Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_BlockSetter_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* + fn set_block(&mut self, block: ::Block) { + ( **self).set_block(block) + } + *) + Definition set_block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockSetter", + T, + [], + "set_block", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| block |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockSetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("set_block", InstanceField.Method (set_block T)) ]. + End Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_BlockSetter_T_for_ref_mut_T. + + Module Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_BlockSetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* + fn set_block(&mut self, block: ::Block) { + ( **self).set_block(block) + } + *) + Definition set_block (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::block::BlockSetter", + T, + [], + "set_block", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| block |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockSetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("set_block", InstanceField.Method (set_block T)) ]. + End Impl_revm_context_interface_block_BlockSetter_where_revm_context_interface_block_BlockSetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. +End block. diff --git a/CoqOfRust/revm/translations/context/interface/block/blob.json b/CoqOfRust/revm/translations/context/interface/block/blob.json new file mode 100644 index 000000000..8bf270a7c --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/block/blob.json @@ -0,0 +1,3452 @@ +[ + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Module": { + "name": "block", + "body": [ + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Module": { + "name": "blob", + "body": [ + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TypeStructStruct": { + "name": "BlobExcessGasAndPrice", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "excess_blob_gas", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "blob_gasprice", + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlobExcessGasAndPrice" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "excess_blob_gas" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob_gasprice" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "blob_gasprice" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "blob_gasprice" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "blob_gasprice" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::block::blob::BlobExcessGasAndPrice" + }, + { + "InternalString": "blob_gasprice" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "new", + "snippet": [ + " pub fn new(excess_blob_gas: u64) -> Self {", + " let blob_gasprice = calc_blob_gasprice(excess_blob_gas);", + " Self {", + " excess_blob_gas,", + " blob_gasprice,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "excess_blob_gas", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "excess_blob_gas", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "blob_gasprice", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "revm_context_interface", + "block", + "blob", + "calc_blob_gasprice" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "block", + "blob", + "BlobExcessGasAndPrice" + ], + "fields": [ + [ + "excess_blob_gas", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + [ + "blob_gasprice", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "blob_gasprice" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Definition": { + "name": "calc_excess_blob_gas", + "path": [ + "revm_context_interface", + "block", + "blob", + "calc_excess_blob_gas" + ], + "snippet": [ + "pub fn calc_excess_blob_gas(parent_excess_blob_gas: u64, parent_blob_gas_used: u64) -> u64 {", + " (parent_excess_blob_gas + parent_blob_gas_used).saturating_sub(TARGET_BLOB_GAS_PER_BLOCK)", + "}" + ], + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "parent_excess_blob_gas", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ], + [ + "parent_blob_gas_used", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "parent_excess_blob_gas", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "parent_excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "parent_blob_gas_used", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "parent_blob_gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "func": "saturating_sub", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.add" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "parent_excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "parent_blob_gas_used" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "TARGET_BLOB_GAS_PER_BLOCK" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Definition": { + "name": "calc_blob_gasprice", + "path": [ + "revm_context_interface", + "block", + "blob", + "calc_blob_gasprice" + ], + "snippet": [ + "pub fn calc_blob_gasprice(excess_blob_gas: u64) -> u128 {", + " fake_exponential(", + " MIN_BLOB_GASPRICE,", + " excess_blob_gas,", + " BLOB_GASPRICE_UPDATE_FRACTION,", + " )", + "}" + ], + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "excess_blob_gas", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "excess_blob_gas", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetFunction": { + "func": [ + "revm_context_interface", + "block", + "blob", + "fake_exponential" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "MIN_BLOB_GASPRICE" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "excess_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "BLOB_GASPRICE_UPDATE_FRACTION" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "file_name": "crates/context/interface/src/block/blob.rs", + "item": { + "Definition": { + "name": "fake_exponential", + "path": [ + "revm_context_interface", + "block", + "blob", + "fake_exponential" + ], + "snippet": [ + "pub fn fake_exponential(factor: u64, numerator: u64, denominator: u64) -> u128 {", + " assert_ne!(denominator, 0, \"attempt to divide by zero\");", + " let factor = factor as u128;", + " let numerator = numerator as u128;", + " let denominator = denominator as u128;", + "", + " let mut i = 1;", + " let mut output = 0;", + " let mut numerator_accum = factor * denominator;", + " while numerator_accum > 0 {", + " output += numerator_accum;", + "", + " // Denominator is asserted as not zero at the start of the function.", + " numerator_accum = (numerator_accum * numerator) / (denominator * i);", + " i += 1;", + " }", + " output / denominator", + "}" + ], + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "factor", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ], + [ + "numerator", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ], + [ + "denominator", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "factor", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "factor" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "numerator", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "numerator" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "denominator", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "denominator" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "LocalVar": "denominator" + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "left_val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "right_val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "left_val" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "right_val" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "kind", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "panicking", + "AssertKind", + "Ne" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "assert_failed" + ], + "generic_tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + }, + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "kind" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "left_val" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "right_val" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "attempt to divide by zero" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "factor", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "factor" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Pure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "numerator", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "numerator" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Pure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "denominator", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "denominator" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Pure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "i", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U128", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U128", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "numerator_accum", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "factor" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "denominator" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Loop": { + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.gt" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "numerator_accum" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U128", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "LocalVar": "output" + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.add" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "numerator_accum" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "numerator_accum" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.div" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "numerator_accum" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "numerator" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "denominator" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "LocalVar": "i" + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.add" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U128", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "ControlFlow": "Break" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.div" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "denominator" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/block/blob.v b/CoqOfRust/revm/translations/context/interface/block/blob.v new file mode 100644 index 000000000..b102981fb --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/block/blob.v @@ -0,0 +1,547 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module block. + Module blob. + (* StructRecord + { + name := "BlobExcessGasAndPrice"; + const_params := []; + ty_params := []; + fields := [ ("excess_blob_gas", Ty.path "u64"); ("blob_gasprice", Ty.path "u128") ]; + } *) + + Module Impl_core_marker_Copy_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_clone_Clone_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.read (| self |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_fmt_Debug_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "BlobExcessGasAndPrice" |); + M.read (| Value.String "excess_blob_gas" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "excess_blob_gas" + |); + M.read (| Value.String "blob_gasprice" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "blob_gasprice" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "excess_blob_gas" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "excess_blob_gas" + |) + |) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "blob_gasprice" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "blob_gasprice" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_cmp_Eq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_core_hash_Hash_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "excess_blob_gas" + |); + M.read (| state |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "u128", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::block::blob::BlobExcessGasAndPrice", + "blob_gasprice" + |); + M.read (| state |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + Module Impl_revm_context_interface_block_blob_BlobExcessGasAndPrice. + Definition Self : Ty.t := + Ty.path "revm_context_interface::block::blob::BlobExcessGasAndPrice". + + (* + pub fn new(excess_blob_gas: u64) -> Self { + let blob_gasprice = calc_blob_gasprice(excess_blob_gas); + Self { + excess_blob_gas, + blob_gasprice, + } + } + *) + Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ excess_blob_gas ] => + ltac:(M.monadic + (let excess_blob_gas := M.alloc (| excess_blob_gas |) in + M.read (| + let~ blob_gasprice := + M.alloc (| + M.call_closure (| + M.get_function (| + "revm_context_interface::block::blob::calc_blob_gasprice", + [] + |), + [ M.read (| excess_blob_gas |) ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::block::blob::BlobExcessGasAndPrice" + [ + ("excess_blob_gas", M.read (| excess_blob_gas |)); + ("blob_gasprice", M.read (| blob_gasprice |)) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new. + End Impl_revm_context_interface_block_blob_BlobExcessGasAndPrice. + + (* + pub fn calc_excess_blob_gas(parent_excess_blob_gas: u64, parent_blob_gas_used: u64) -> u64 { + (parent_excess_blob_gas + parent_blob_gas_used).saturating_sub(TARGET_BLOB_GAS_PER_BLOCK) + } + *) + Definition calc_excess_blob_gas (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ parent_excess_blob_gas; parent_blob_gas_used ] => + ltac:(M.monadic + (let parent_excess_blob_gas := M.alloc (| parent_excess_blob_gas |) in + let parent_blob_gas_used := M.alloc (| parent_blob_gas_used |) in + M.call_closure (| + M.get_associated_function (| Ty.path "u64", "saturating_sub", [] |), + [ + BinOp.Wrap.add (| + M.read (| parent_excess_blob_gas |), + M.read (| parent_blob_gas_used |) + |); + M.read (| + M.get_constant (| "revm_specification::eip4844::TARGET_BLOB_GAS_PER_BLOCK" |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Function_calc_excess_blob_gas : + M.IsFunction "revm_context_interface::block::blob::calc_excess_blob_gas" calc_excess_blob_gas. + + (* + pub fn calc_blob_gasprice(excess_blob_gas: u64) -> u128 { + fake_exponential( + MIN_BLOB_GASPRICE, + excess_blob_gas, + BLOB_GASPRICE_UPDATE_FRACTION, + ) + } + *) + Definition calc_blob_gasprice (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ excess_blob_gas ] => + ltac:(M.monadic + (let excess_blob_gas := M.alloc (| excess_blob_gas |) in + M.call_closure (| + M.get_function (| "revm_context_interface::block::blob::fake_exponential", [] |), + [ + M.read (| M.get_constant (| "revm_specification::eip4844::MIN_BLOB_GASPRICE" |) |); + M.read (| excess_blob_gas |); + M.read (| + M.get_constant (| "revm_specification::eip4844::BLOB_GASPRICE_UPDATE_FRACTION" |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Function_calc_blob_gasprice : + M.IsFunction "revm_context_interface::block::blob::calc_blob_gasprice" calc_blob_gasprice. + + (* + pub fn fake_exponential(factor: u64, numerator: u64, denominator: u64) -> u128 { + assert_ne!(denominator, 0, "attempt to divide by zero"); + let factor = factor as u128; + let numerator = numerator as u128; + let denominator = denominator as u128; + + let mut i = 1; + let mut output = 0; + let mut numerator_accum = factor * denominator; + while numerator_accum > 0 { + output += numerator_accum; + + // Denominator is asserted as not zero at the start of the function. + numerator_accum = (numerator_accum * numerator) / (denominator * i); + i += 1; + } + output / denominator + } + *) + Definition fake_exponential (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ factor; numerator; denominator ] => + ltac:(M.monadic + (let factor := M.alloc (| factor |) in + let numerator := M.alloc (| numerator |) in + let denominator := M.alloc (| denominator |) in + M.read (| + let~ _ := + M.match_operator (| + M.alloc (| + Value.Tuple [ denominator; M.alloc (| Value.Integer IntegerKind.U64 0 |) ] + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let left_val := M.copy (| γ0_0 |) in + let right_val := M.copy (| γ0_1 |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + BinOp.eq (| + M.read (| M.read (| left_val |) |), + M.read (| M.read (| right_val |) |) + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ kind := + M.alloc (| + Value.StructTuple "core::panicking::AssertKind::Ne" [] + |) in + M.alloc (| + M.call_closure (| + M.get_function (| + "core::panicking::assert_failed", + [ Ty.path "u64"; Ty.path "u64" ] + |), + [ + M.read (| kind |); + M.read (| left_val |); + M.read (| right_val |); + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "attempt to divide by zero" + |) + ] + |) + ] + |) + ] + ] + |) + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |) in + let~ factor := M.alloc (| M.rust_cast (M.read (| factor |)) |) in + let~ numerator := M.alloc (| M.rust_cast (M.read (| numerator |)) |) in + let~ denominator := M.alloc (| M.rust_cast (M.read (| denominator |)) |) in + let~ i := M.alloc (| Value.Integer IntegerKind.U128 1 |) in + let~ output := M.alloc (| Value.Integer IntegerKind.U128 0 |) in + let~ numerator_accum := + M.alloc (| BinOp.Wrap.mul (| M.read (| factor |), M.read (| denominator |) |) |) in + let~ _ := + M.loop (| + ltac:(M.monadic + (M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + BinOp.gt (| + M.read (| numerator_accum |), + Value.Integer IntegerKind.U128 0 + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ _ := + let β := output in + M.write (| + β, + BinOp.Wrap.add (| M.read (| β |), M.read (| numerator_accum |) |) + |) in + let~ _ := + M.write (| + numerator_accum, + BinOp.Wrap.div (| + BinOp.Wrap.mul (| + M.read (| numerator_accum |), + M.read (| numerator |) + |), + BinOp.Wrap.mul (| M.read (| denominator |), M.read (| i |) |) + |) + |) in + let~ _ := + let β := i in + M.write (| + β, + BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.U128 1 |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.never_to_any (| + M.read (| + let~ _ := + M.alloc (| M.never_to_any (| M.read (| M.break (||) |) |) |) in + M.alloc (| Value.Tuple [] |) + |) + |) + |))) + ] + |))) + |) in + M.alloc (| BinOp.Wrap.div (| M.read (| output |), M.read (| denominator |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Function_fake_exponential : + M.IsFunction "revm_context_interface::block::blob::fake_exponential" fake_exponential. + End blob. +End block. diff --git a/CoqOfRust/revm/translations/context/interface/cfg.json b/CoqOfRust/revm/translations/context/interface/cfg.json new file mode 100644 index 000000000..08fb1ccd6 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/cfg.json @@ -0,0 +1,11121 @@ +[ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "cfg", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Trait": { + "name": "Cfg", + "path": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Spec", + { + "Type": [] + } + ], + [ + "chain_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "spec", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": "Associated" + } + } + } + } + ], + [ + "max_code_size", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "usize" + ] + } + } + } + } + } + } + ], + [ + "is_eip3607_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ], + [ + "is_balance_check_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ], + [ + "is_gas_refund_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ], + [ + "is_block_gas_limit_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ], + [ + "is_nonce_check_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ], + [ + "is_base_fee_check_disabled", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_code_size", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_code_size", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_eip3607_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_eip3607_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_balance_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_balance_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_gas_refund_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_gas_refund_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_block_gas_limit_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_block_gas_limit_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_nonce_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_nonce_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_base_fee_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_base_fee_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_code_size", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_code_size", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_eip3607_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_eip3607_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_balance_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_balance_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_gas_refund_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_gas_refund_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_block_gas_limit_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_block_gas_limit_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_nonce_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_nonce_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_base_fee_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_base_fee_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_code_size", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_code_size", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_eip3607_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_eip3607_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_balance_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_balance_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_gas_refund_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_gas_refund_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_block_gas_limit_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_block_gas_limit_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_nonce_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_nonce_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_base_fee_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_base_fee_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "spec", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "spec", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_code_size", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_code_size", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_eip3607_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_eip3607_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_balance_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_balance_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_gas_refund_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_gas_refund_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_block_gas_limit_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_block_gas_limit_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_nonce_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_nonce_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_base_fee_check_disabled", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_base_fee_check_disabled", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TypeEnum": { + "name": "AnalysisKind", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Raw", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Analyse", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::AnalysisKind::Raw" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind", + "Raw" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::AnalysisKind::Analyse" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind", + "Analyse" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind", + "Analyse" + ], + "fields": [] + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::AnalysisKind::Raw" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Raw" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::AnalysisKind::Analyse" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Analyse" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "AnalysisKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TypeAlias": { + "name": "TransactTo", + "path": [ + "revm_context_interface", + "cfg", + "TransactTo" + ], + "const_params": [], + "ty_params": [], + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TypeEnum": { + "name": "CreateScheme", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Create", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Create2", + "item": { + "Struct": { + "fields": [ + [ + "salt", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::CreateScheme::Create" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Create" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::CreateScheme::Create2" + }, + { + "InternalString": "salt" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Create2" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "salt" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::cfg::CreateScheme::Create2" + }, + { + "InternalString": "salt" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::cfg::CreateScheme::Create2" + }, + { + "InternalString": "salt" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "cfg", + "CreateScheme" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::cfg::CreateScheme::Create2" + }, + { + "InternalString": "salt" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Trait": { + "name": "CfgGetter", + "path": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Cfg", + { + "Type": [] + } + ], + [ + "cfg", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "cfg", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "cfg", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "cfg", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/cfg.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "cfg", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "cfg", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/cfg.v b/CoqOfRust/revm/translations/context/interface/cfg.v new file mode 100644 index 000000000..59394e27a --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/cfg.v @@ -0,0 +1,1792 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module cfg. + (* Trait *) + (* Empty module 'Cfg' *) + + Module underscore. + Module Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Spec (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "chain_id", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition spec (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "spec", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition max_code_size + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "max_code_size", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_eip3607_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_eip3607_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_balance_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_balance_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_gas_refund_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_gas_refund_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_block_gas_limit_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_block_gas_limit_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_nonce_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_nonce_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_base_fee_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_base_fee_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::Cfg" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Spec", InstanceField.Ty (_Spec T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("spec", InstanceField.Method (spec T)); + ("max_code_size", InstanceField.Method (max_code_size T)); + ("is_eip3607_disabled", InstanceField.Method (is_eip3607_disabled T)); + ("is_balance_check_disabled", InstanceField.Method (is_balance_check_disabled T)); + ("is_gas_refund_disabled", InstanceField.Method (is_gas_refund_disabled T)); + ("is_block_gas_limit_disabled", InstanceField.Method (is_block_gas_limit_disabled T)); + ("is_nonce_check_disabled", InstanceField.Method (is_nonce_check_disabled T)); + ("is_base_fee_check_disabled", InstanceField.Method (is_base_fee_check_disabled T)) + ]. + End Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Spec (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "chain_id", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition spec (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "spec", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition max_code_size + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "max_code_size", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_eip3607_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_eip3607_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_balance_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_balance_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_gas_refund_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_gas_refund_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_block_gas_limit_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_block_gas_limit_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_nonce_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_nonce_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_base_fee_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_base_fee_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::Cfg" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Spec", InstanceField.Ty (_Spec T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("spec", InstanceField.Method (spec T)); + ("max_code_size", InstanceField.Method (max_code_size T)); + ("is_eip3607_disabled", InstanceField.Method (is_eip3607_disabled T)); + ("is_balance_check_disabled", InstanceField.Method (is_balance_check_disabled T)); + ("is_gas_refund_disabled", InstanceField.Method (is_gas_refund_disabled T)); + ("is_block_gas_limit_disabled", InstanceField.Method (is_block_gas_limit_disabled T)); + ("is_nonce_check_disabled", InstanceField.Method (is_nonce_check_disabled T)); + ("is_base_fee_check_disabled", InstanceField.Method (is_base_fee_check_disabled T)) + ]. + End Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Spec (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "chain_id", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition spec (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "spec", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition max_code_size + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "max_code_size", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_eip3607_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_eip3607_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_balance_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_balance_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_gas_refund_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_gas_refund_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_block_gas_limit_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_block_gas_limit_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_nonce_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_nonce_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_base_fee_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_base_fee_check_disabled", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::Cfg" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Spec", InstanceField.Ty (_Spec T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("spec", InstanceField.Method (spec T)); + ("max_code_size", InstanceField.Method (max_code_size T)); + ("is_eip3607_disabled", InstanceField.Method (is_eip3607_disabled T)); + ("is_balance_check_disabled", InstanceField.Method (is_balance_check_disabled T)); + ("is_gas_refund_disabled", InstanceField.Method (is_gas_refund_disabled T)); + ("is_block_gas_limit_disabled", InstanceField.Method (is_block_gas_limit_disabled T)); + ("is_nonce_check_disabled", InstanceField.Method (is_nonce_check_disabled T)); + ("is_base_fee_check_disabled", InstanceField.Method (is_base_fee_check_disabled T)) + ]. + End Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Spec (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "chain_id", [] |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition spec (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::Cfg", T, [], "spec", [] |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition max_code_size + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "max_code_size", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_eip3607_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_eip3607_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_balance_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_balance_check_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_gas_refund_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_gas_refund_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_block_gas_limit_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_block_gas_limit_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_nonce_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_nonce_check_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition is_base_fee_check_disabled + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::cfg::Cfg", + T, + [], + "is_base_fee_check_disabled", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::Cfg" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Spec", InstanceField.Ty (_Spec T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("spec", InstanceField.Method (spec T)); + ("max_code_size", InstanceField.Method (max_code_size T)); + ("is_eip3607_disabled", InstanceField.Method (is_eip3607_disabled T)); + ("is_balance_check_disabled", InstanceField.Method (is_balance_check_disabled T)); + ("is_gas_refund_disabled", InstanceField.Method (is_gas_refund_disabled T)); + ("is_block_gas_limit_disabled", InstanceField.Method (is_block_gas_limit_disabled T)); + ("is_nonce_check_disabled", InstanceField.Method (is_nonce_check_disabled T)); + ("is_base_fee_check_disabled", InstanceField.Method (is_base_fee_check_disabled T)) + ]. + End Impl_revm_context_interface_cfg_Cfg_where_revm_context_interface_cfg_Cfg_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Cfg (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition cfg (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::CfgGetter", T, [], "cfg", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Cfg", InstanceField.Ty (_Cfg T)); ("cfg", InstanceField.Method (cfg T)) ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Cfg (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition cfg (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::CfgGetter", T, [], "cfg", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Cfg", InstanceField.Ty (_Cfg T)); ("cfg", InstanceField.Method (cfg T)) ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Cfg (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition cfg (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::CfgGetter", T, [], "cfg", [] |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Cfg", InstanceField.Ty (_Cfg T)); ("cfg", InstanceField.Method (cfg T)) ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Cfg (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition cfg (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::cfg::CfgGetter", T, [], "cfg", [] |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Cfg", InstanceField.Ty (_Cfg T)); ("cfg", InstanceField.Method (cfg T)) ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_cfg_CfgGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + End underscore. + + + + + (* + Enum AnalysisKind + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Raw"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Analyse"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_clone_Clone_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| γ, "revm_context_interface::cfg::AnalysisKind::Raw" |) in + M.alloc (| + Value.StructTuple "revm_context_interface::cfg::AnalysisKind::Raw" [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::cfg::AnalysisKind::Analyse" + |) in + M.alloc (| + Value.StructTuple "revm_context_interface::cfg::AnalysisKind::Analyse" [] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_default_Default_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* Default *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic (Value.StructTuple "revm_context_interface::cfg::AnalysisKind::Analyse" [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_fmt_Debug_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::cfg::AnalysisKind::Raw" + |) in + M.alloc (| M.read (| Value.String "Raw" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::cfg::AnalysisKind::Analyse" + |) in + M.alloc (| M.read (| Value.String "Analyse" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_cmp_Eq_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::AnalysisKind" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::AnalysisKind" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_cfg_AnalysisKind. + + Module Impl_core_hash_Hash_for_revm_context_interface_cfg_AnalysisKind. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::AnalysisKind". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::AnalysisKind" ] + |), + [ M.read (| self |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_cfg_AnalysisKind. + + Axiom TransactTo : + (Ty.path "revm_context_interface::cfg::TransactTo") = + (Ty.path "alloy_primitives::common::TxKind"). + + (* + Enum CreateScheme + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Create"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Create2"; + item := + StructRecord + [ + ("salt", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_clone_Clone_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.read (| self |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_marker_Copy_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_fmt_Debug_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::cfg::CreateScheme::Create" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "Create" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::cfg::CreateScheme::Create2", + "salt" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Create2" |); + M.read (| Value.String "salt" |); + __self_0 + ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_cmp_Eq_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::CreateScheme" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::CreateScheme" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::cfg::CreateScheme::Create2", + "salt" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::cfg::CreateScheme::Create2", + "salt" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool true |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_cfg_CreateScheme. + + Module Impl_core_hash_Hash_for_revm_context_interface_cfg_CreateScheme. + Definition Self : Ty.t := Ty.path "revm_context_interface::cfg::CreateScheme". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::cfg::CreateScheme" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::cfg::CreateScheme::Create2", + "salt" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_cfg_CreateScheme. + + (* Trait *) + (* Empty module 'CfgGetter' *) + + + + +End cfg. diff --git a/CoqOfRust/revm/translations/context/interface/errors.json b/CoqOfRust/revm/translations/context/interface/errors.json new file mode 100644 index 000000000..0a12f5423 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/errors.json @@ -0,0 +1,601 @@ +[ + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "Module": { + "name": "errors", + "body": [ + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "Trait": { + "name": "ErrorGetter", + "path": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Error", + { + "Type": [] + } + ], + [ + "take_error", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Error", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "take_error", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "take_error", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/errors.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Error", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "take_error", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "errors", + "ErrorGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "take_error", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/errors.v b/CoqOfRust/revm/translations/context/interface/errors.v new file mode 100644 index 000000000..0c5aaccf6 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/errors.v @@ -0,0 +1,88 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module errors. + (* Trait *) + (* Empty module 'ErrorGetter' *) + + Module underscore. + Module Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_errors_ErrorGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&mut, Box)] *) + Definition _Error (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&mut, Box)] *) + Definition take_error (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::errors::ErrorGetter", + T, + [], + "take_error", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::errors::ErrorGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Error", InstanceField.Ty (_Error T)); + ("take_error", InstanceField.Method (take_error T)) + ]. + End Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_errors_ErrorGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_errors_ErrorGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&mut, Box)] *) + Definition _Error (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&mut, Box)] *) + Definition take_error (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::errors::ErrorGetter", + T, + [], + "take_error", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::errors::ErrorGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Error", InstanceField.Ty (_Error T)); + ("take_error", InstanceField.Method (take_error T)) + ]. + End Impl_revm_context_interface_errors_ErrorGetter_where_revm_context_interface_errors_ErrorGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + End underscore. + +End errors. diff --git a/CoqOfRust/revm/translations/context/interface/host.json b/CoqOfRust/revm/translations/context/interface/host.json new file mode 100644 index 000000000..2598a7584 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/host.json @@ -0,0 +1,12607 @@ +[ + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "Module": { + "name": "host", + "body": [ + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "Trait": { + "name": "Host", + "path": [ + "revm_context_interface", + "host", + "Host" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "load_account_delegated", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "block_hash", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "balance", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "code", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "code_hash", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "sload", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "sstore", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "tload", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + } + } + } + } + ], + [ + "tstore", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "log", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "selfdestruct", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "host", + "Host" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "host", + "Host" + ], + "trait_ty_params": [], + "items": [ + { + "name": "load_account_delegated", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "load_account_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "block_hash", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "number", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "number", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "number" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "balance", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "balance", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code_hash", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "code_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "sload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "sstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "log", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "host", + "Host" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "host", + "Host" + ], + "trait_ty_params": [], + "items": [ + { + "name": "load_account_delegated", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "load_account_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "block_hash", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "number", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "number", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "number" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "block_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "number" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "balance", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "balance", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code_hash", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "code_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "sload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "sstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "log", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + "#[auto_impl(&mut, Box)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "host", + "Host" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TypeStructStruct": { + "name": "SStoreResult", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "original_value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "present_value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "new_value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ], + "fields": [ + [ + "original_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "present_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "new_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field3_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SStoreResult" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "original_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "present_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "new_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ], + "fields": [ + [ + "original_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "present_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "new_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "is_new_eq_present", + "snippet": [ + " pub fn is_new_eq_present(&self) -> bool {", + " self.new_value == self.present_value", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_original_eq_present", + "snippet": [ + " pub fn is_original_eq_present(&self) -> bool {", + " self.original_value == self.present_value", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_original_eq_new", + "snippet": [ + " pub fn is_original_eq_new(&self) -> bool {", + " self.original_value == self.new_value", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_original_zero", + "snippet": [ + " pub fn is_original_zero(&self) -> bool {", + " self.original_value.is_zero()", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "original_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_present_zero", + "snippet": [ + " pub fn is_present_zero(&self) -> bool {", + " self.present_value.is_zero()", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_new_zero", + "snippet": [ + " pub fn is_new_zero(&self) -> bool {", + " self.new_value.is_zero()", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SStoreResult" + }, + { + "InternalString": "new_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TypeStructStruct": { + "name": "SelfDestructResult", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "had_value", + { + "Path": { + "path": [ + "bool" + ] + } + } + ], + [ + "target_exists", + { + "Path": { + "path": [ + "bool" + ] + } + } + ], + [ + "previously_destroyed", + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ], + "fields": [ + [ + "had_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "target_exists", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "target_exists" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "previously_destroyed", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field3_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SelfDestructResult" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "had_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "target_exists" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "target_exists" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "previously_destroyed" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ], + "fields": [ + [ + "had_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "target_exists", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "previously_destroyed", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "target_exists" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "target_exists" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "target_exists" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::SelfDestructResult" + }, + { + "InternalString": "previously_destroyed" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/host.v b/CoqOfRust/revm/translations/context/interface/host.v new file mode 100644 index 000000000..be2a8dcfb --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/host.v @@ -0,0 +1,1458 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module host. + (* Trait *) + (* Empty module 'Host' *) + + Module underscore. + Module Impl_revm_context_interface_host_Host_where_revm_context_interface_host_Host_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_TransactionGetter_ref_mut_T_where_revm_context_interface_block_BlockGetter_ref_mut_T_where_revm_context_interface_cfg_CfgGetter_ref_mut_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&mut, Box)] *) + Definition load_account_delegated + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "load_account_delegated", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition block_hash (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; number ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let number := M.alloc (| number |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "block_hash", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| number |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition balance (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "balance", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition code (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "code", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition code_hash (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "code_hash", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition sload (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "sload", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| index |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition sstore (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "sstore", [] |), + [ + M.read (| M.read (| self |) |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition tload (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "tload", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| index |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition tstore (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "tstore", [] |), + [ + M.read (| M.read (| self |) |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition log (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "log", [] |), + [ M.read (| M.read (| self |) |); M.read (| log |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition selfdestruct + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let target := M.alloc (| target |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "selfdestruct", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| target |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::host::Host" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("load_account_delegated", InstanceField.Method (load_account_delegated T)); + ("block_hash", InstanceField.Method (block_hash T)); + ("balance", InstanceField.Method (balance T)); + ("code", InstanceField.Method (code T)); + ("code_hash", InstanceField.Method (code_hash T)); + ("sload", InstanceField.Method (sload T)); + ("sstore", InstanceField.Method (sstore T)); + ("tload", InstanceField.Method (tload T)); + ("tstore", InstanceField.Method (tstore T)); + ("log", InstanceField.Method (log T)); + ("selfdestruct", InstanceField.Method (selfdestruct T)) + ]. + End Impl_revm_context_interface_host_Host_where_revm_context_interface_host_Host_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_TransactionGetter_ref_mut_T_where_revm_context_interface_block_BlockGetter_ref_mut_T_where_revm_context_interface_cfg_CfgGetter_ref_mut_T_for_ref_mut_T. + Module Impl_revm_context_interface_host_Host_where_revm_context_interface_host_Host_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_TransactionGetter_alloc_boxed_Box_T_alloc_alloc_Global_where_revm_context_interface_block_BlockGetter_alloc_boxed_Box_T_alloc_alloc_Global_where_revm_context_interface_cfg_CfgGetter_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&mut, Box)] *) + Definition load_account_delegated + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "load_account_delegated", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition block_hash (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; number ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let number := M.alloc (| number |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "block_hash", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| number |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition balance (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "balance", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition code (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "code", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition code_hash (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "code_hash", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition sload (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "sload", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| index |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition sstore (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "sstore", [] |), + [ + M.read (| M.read (| self |) |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition tload (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "tload", [] |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| index |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition tstore (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "tstore", [] |), + [ + M.read (| M.read (| self |) |); + M.read (| address |); + M.read (| index |); + M.read (| value |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition log (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.call_closure (| + M.get_trait_method (| "revm_context_interface::host::Host", T, [], "log", [] |), + [ M.read (| M.read (| self |) |); M.read (| log |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&mut, Box)] *) + Definition selfdestruct + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; address; target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let target := M.alloc (| target |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::host::Host", + T, + [], + "selfdestruct", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| address |); M.read (| target |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::host::Host" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("load_account_delegated", InstanceField.Method (load_account_delegated T)); + ("block_hash", InstanceField.Method (block_hash T)); + ("balance", InstanceField.Method (balance T)); + ("code", InstanceField.Method (code T)); + ("code_hash", InstanceField.Method (code_hash T)); + ("sload", InstanceField.Method (sload T)); + ("sstore", InstanceField.Method (sstore T)); + ("tload", InstanceField.Method (tload T)); + ("tstore", InstanceField.Method (tstore T)); + ("log", InstanceField.Method (log T)); + ("selfdestruct", InstanceField.Method (selfdestruct T)) + ]. + End Impl_revm_context_interface_host_Host_where_revm_context_interface_host_Host_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_TransactionGetter_alloc_boxed_Box_T_alloc_alloc_Global_where_revm_context_interface_block_BlockGetter_alloc_boxed_Box_T_alloc_alloc_Global_where_revm_context_interface_cfg_CfgGetter_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + End underscore. + + + (* StructRecord + { + name := "SStoreResult"; + const_params := []; + ty_params := []; + fields := + [ + ("original_value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("present_value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("new_value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + } *) + + Module Impl_core_clone_Clone_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::host::SStoreResult" + [ + ("original_value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |) + ] + |)); + ("present_value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |) + ] + |)); + ("new_value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_host_SStoreResult. + + Module Impl_core_fmt_Debug_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field3_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "SStoreResult" |); + M.read (| Value.String "original_value" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |); + M.read (| Value.String "present_value" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |); + M.read (| Value.String "new_value" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_host_SStoreResult. + + Module Impl_core_default_Default_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* Default *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::host::SStoreResult" + [ + ("original_value", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "default", + [] + |), + [] + |)); + ("present_value", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "default", + [] + |), + [] + |)); + ("new_value", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_interface_host_SStoreResult. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_host_SStoreResult. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SStoreResult", + "original_value" + |) + ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SStoreResult", + "present_value" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SStoreResult", + "new_value" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_host_SStoreResult. + + Module Impl_core_cmp_Eq_for_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_host_SStoreResult. + + Module Impl_revm_context_interface_host_SStoreResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SStoreResult". + + (* + pub fn is_new_eq_present(&self) -> bool { + self.new_value == self.present_value + } + *) + Definition is_new_eq_present (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_new_eq_present : + M.IsAssociatedFunction Self "is_new_eq_present" is_new_eq_present. + + (* + pub fn is_original_eq_present(&self) -> bool { + self.original_value == self.present_value + } + *) + Definition is_original_eq_present (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_original_eq_present : + M.IsAssociatedFunction Self "is_original_eq_present" is_original_eq_present. + + (* + pub fn is_original_eq_new(&self) -> bool { + self.original_value == self.new_value + } + *) + Definition is_original_eq_new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_original_eq_new : + M.IsAssociatedFunction Self "is_original_eq_new" is_original_eq_new. + + (* + pub fn is_original_zero(&self) -> bool { + self.original_value.is_zero() + } + *) + Definition is_original_zero (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "is_zero", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "original_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_original_zero : + M.IsAssociatedFunction Self "is_original_zero" is_original_zero. + + (* + pub fn is_present_zero(&self) -> bool { + self.present_value.is_zero() + } + *) + Definition is_present_zero (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "is_zero", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "present_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_present_zero : + M.IsAssociatedFunction Self "is_present_zero" is_present_zero. + + (* + pub fn is_new_zero(&self) -> bool { + self.new_value.is_zero() + } + *) + Definition is_new_zero (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "is_zero", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SStoreResult", + "new_value" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_new_zero : M.IsAssociatedFunction Self "is_new_zero" is_new_zero. + End Impl_revm_context_interface_host_SStoreResult. + + (* StructRecord + { + name := "SelfDestructResult"; + const_params := []; + ty_params := []; + fields := + [ + ("had_value", Ty.path "bool"); + ("target_exists", Ty.path "bool"); + ("previously_destroyed", Ty.path "bool") + ]; + } *) + + Module Impl_core_clone_Clone_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::host::SelfDestructResult" + [ + ("had_value", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "had_value" + |) + ] + |)); + ("target_exists", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "target_exists" + |) + ] + |)); + ("previously_destroyed", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "previously_destroyed" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_fmt_Debug_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field3_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "SelfDestructResult" |); + M.read (| Value.String "had_value" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "had_value" + |); + M.read (| Value.String "target_exists" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "target_exists" + |); + M.read (| Value.String "previously_destroyed" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "previously_destroyed" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_default_Default_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* Default *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::host::SelfDestructResult" + [ + ("had_value", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "bool", + [], + "default", + [] + |), + [] + |)); + ("target_exists", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "bool", + [], + "default", + [] + |), + [] + |)); + ("previously_destroyed", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "bool", + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "had_value" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SelfDestructResult", + "had_value" + |) + |) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "target_exists" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SelfDestructResult", + "target_exists" + |) + |) + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "previously_destroyed" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::host::SelfDestructResult", + "previously_destroyed" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_cmp_Eq_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_host_SelfDestructResult. + + Module Impl_core_hash_Hash_for_revm_context_interface_host_SelfDestructResult. + Definition Self : Ty.t := Ty.path "revm_context_interface::host::SelfDestructResult". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "bool", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "had_value" + |); + M.read (| state |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "bool", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "target_exists" + |); + M.read (| state |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "bool", [], "hash", [ __H ] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::SelfDestructResult", + "previously_destroyed" + |); + M.read (| state |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_host_SelfDestructResult. +End host. diff --git a/CoqOfRust/revm/translations/context/interface/host/dummy.json b/CoqOfRust/revm/translations/context/interface/host/dummy.json new file mode 100644 index 000000000..83802e1b3 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/host/dummy.json @@ -0,0 +1,9113 @@ +[ + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "Module": { + "name": "host", + "body": [ + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "Module": { + "name": "dummy", + "body": [ + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TypeStructStruct": { + "name": "DummyHost", + "const_params": [], + "ty_params": [ + "BLOCK", + "TX", + "CFG" + ], + "fields": [ + [ + "tx", + { + "Var": { + "name": "TX" + } + } + ], + [ + "block", + { + "Var": { + "name": "BLOCK" + } + } + ], + [ + "cfg", + { + "Var": { + "name": "CFG" + } + } + ], + [ + "storage", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "transient_storage", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "TX" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "BLOCK" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "transient_storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "log", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "names", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "tx" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "block" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "cfg" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "storage" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "transient_storage" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "log" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "values", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_fields_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "DummyHost" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "names" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "values" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "default", + "Default" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "core", + "default", + "Default" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "core", + "default", + "Default" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "TX" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "BLOCK" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "transient_storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "log", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "items": [ + { + "name": "new", + "snippet": [ + " pub fn new(tx: TX, block: BLOCK) -> Self {", + " Self {", + " tx,", + " block,", + " cfg: CFG::default(),", + " storage: HashMap::default(),", + " transient_storage: HashMap::default(),", + " log: Vec::new(),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "tx", + { + "Var": { + "name": "TX" + } + }, + null + ], + [ + "block", + { + "Var": { + "name": "BLOCK" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "body": { + "Let": { + "name": "tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Effectful" + } + } + ], + [ + "block", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + [ + "cfg", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "CFG" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "transient_storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "log", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "clear", + "snippet": [ + " pub fn clear(&mut self) {", + " self.storage.clear();", + " self.log.clear();", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "block", + "BlockGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Block", + "snippet": [ + " type Block = BLOCK;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "BLOCK" + } + } + } + } + } + }, + { + "name": "block", + "snippet": [ + " fn block(&self) -> &Self::Block {", + " &self.block", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "block" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + " type Transaction = TX;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "TX" + } + } + } + } + } + }, + { + "name": "tx", + "snippet": [ + " fn tx(&self) -> &Self::Transaction {", + " &self.tx", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "BLOCK", + "TX", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "cfg", + "CfgGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Cfg", + "snippet": [ + " type Cfg = CFG;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "CFG" + } + } + } + } + } + }, + { + "name": "cfg", + "snippet": [ + " fn cfg(&self) -> &Self::Cfg {", + " &self.cfg", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "cfg" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/host/dummy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "TX", + "BLOCK", + "CFG" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TX" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "block", + "Block" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "BLOCK" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "cfg", + "Cfg" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "CFG" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "host", + "Host" + ], + "trait_ty_params": [], + "items": [ + { + "name": "load_account_delegated", + "snippet": [ + " fn load_account_delegated(&mut self, _address: Address) -> Option {", + " Some(AccountLoad::default())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "block_hash", + "snippet": [ + " fn block_hash(&mut self, _number: u64) -> Option {", + " Some(B256::ZERO)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_number", + { + "Path": { + "path": [ + "u64" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_number", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_number" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "alloy_primitives", + "bits", + "fixed", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "balance", + "snippet": [ + " fn balance(&mut self, _address: Address) -> Option> {", + " Some(Default::default())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code", + "snippet": [ + " fn code(&mut self, _address: Address) -> Option> {", + " Some(Default::default())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "code_hash", + "snippet": [ + " fn code_hash(&mut self, _address: Address) -> Option> {", + " Some(Eip7702CodeLoad::new_not_delegated(KECCAK_EMPTY, false))", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_primitives", + "KECCAK_EMPTY" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + " fn sload(&mut self, _address: Address, index: U256) -> Option> {", + " match self.storage.entry(index) {", + " Entry::Occupied(entry) => Some(StateLoad::new(*entry.get(), false)),", + " Entry::Vacant(entry) => {", + " entry.insert(U256::ZERO);", + " Some(StateLoad::new(U256::ZERO, true))", + " }", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "entry", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Occupied" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "OccupiedEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Vacant" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "VacantEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + " fn sstore(", + " &mut self,", + " _address: Address,", + " index: U256,", + " value: U256,", + " ) -> Option> {", + " let present = self.storage.insert(index, value);", + " Some(StateLoad {", + " data: SStoreResult {", + " original_value: U256::ZERO,", + " present_value: present.unwrap_or(U256::ZERO),", + " new_value: value,", + " },", + " is_cold: present.is_none(),", + " })", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "present", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ], + "fields": [ + [ + "original_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "present_value", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "present" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "new_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "is_none", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "present" + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + " fn tload(&mut self, _address: Address, index: U256) -> U256 {", + " self.transient_storage", + " .get(&index)", + " .copied()", + " .unwrap_or_default()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "copied", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "index" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + " fn tstore(&mut self, _address: Address, index: U256, value: U256) {", + " self.transient_storage.insert(index, value);", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "index", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "index", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "index" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + " fn log(&mut self, log: Log) {", + " self.log.push(log)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::host::dummy::DummyHost" + }, + { + "InternalString": "log" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + " fn selfdestruct(", + " &mut self,", + " _address: Address,", + " _target: Address,", + " ) -> Option> {", + " Some(StateLoad::default())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "dummy", + "DummyHost" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "BLOCK" + } + }, + { + "Var": { + "name": "TX" + } + }, + { + "Var": { + "name": "CFG" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "_target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "_target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "_target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/host/dummy.v b/CoqOfRust/revm/translations/context/interface/host/dummy.v new file mode 100644 index 000000000..31a7d4c42 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/host/dummy.v @@ -0,0 +1,1563 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module host. + Module dummy. + (* StructRecord + { + name := "DummyHost"; + const_params := []; + ty_params := [ "BLOCK"; "TX"; "CFG" ]; + fields := + [ + ("tx", TX); + ("block", BLOCK); + ("cfg", CFG); + ("storage", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]); + ("transient_storage", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]); + ("log", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ]) + ]; + } *) + + Module Impl_core_clone_Clone_where_core_clone_Clone_BLOCK_where_core_clone_Clone_TX_where_core_clone_Clone_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* Clone *) + Definition clone + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::host::dummy::DummyHost" + [ + ("tx", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", TX, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "tx" + |) + ] + |)); + ("block", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", BLOCK, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "block" + |) + ] + |)); + ("cfg", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", CFG, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "cfg" + |) + ] + |)); + ("storage", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "storage" + |) + ] + |)); + ("transient_storage", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "transient_storage" + |) + ] + |)); + ("log", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "log" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone BLOCK TX CFG)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_BLOCK_where_core_clone_Clone_TX_where_core_clone_Clone_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_BLOCK_where_core_fmt_Debug_TX_where_core_fmt_Debug_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* Debug *) + Definition fmt + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ names := + M.alloc (| + M.alloc (| + Value.Array + [ + M.read (| Value.String "tx" |); + M.read (| Value.String "block" |); + M.read (| Value.String "cfg" |); + M.read (| Value.String "storage" |); + M.read (| Value.String "transient_storage" |); + M.read (| Value.String "log" |) + ] + |) + |) in + let~ values := + M.alloc (| + M.alloc (| + Value.Array + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "tx" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "block" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "cfg" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "storage" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "transient_storage" + |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "log" + |) + |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_fields_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "DummyHost" |); + M.read (| names |); + M.read (| values |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt BLOCK TX CFG)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_BLOCK_where_core_fmt_Debug_TX_where_core_fmt_Debug_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_core_default_Default_where_core_default_Default_BLOCK_where_core_default_Default_TX_where_core_default_Default_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* Default *) + Definition default + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::host::dummy::DummyHost" + [ + ("tx", + M.call_closure (| + M.get_trait_method (| "core::default::Default", TX, [], "default", [] |), + [] + |)); + ("block", + M.call_closure (| + M.get_trait_method (| "core::default::Default", BLOCK, [], "default", [] |), + [] + |)); + ("cfg", + M.call_closure (| + M.get_trait_method (| "core::default::Default", CFG, [], "default", [] |), + [] + |)); + ("storage", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("transient_storage", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("log", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "core::default::Default" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method (default BLOCK TX CFG)) ]. + End Impl_core_default_Default_where_core_default_Default_BLOCK_where_core_default_Default_TX_where_core_default_Default_CFG_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* + pub fn new(tx: TX, block: BLOCK) -> Self { + Self { + tx, + block, + cfg: CFG::default(), + storage: HashMap::default(), + transient_storage: HashMap::default(), + log: Vec::new(), + } + } + *) + Definition new + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ tx; block ] => + ltac:(M.monadic + (let tx := M.alloc (| tx |) in + let block := M.alloc (| block |) in + Value.StructRecord + "revm_context_interface::host::dummy::DummyHost" + [ + ("tx", M.read (| tx |)); + ("block", M.read (| block |)); + ("cfg", + M.call_closure (| + M.get_trait_method (| "core::default::Default", CFG, [], "default", [] |), + [] + |)); + ("storage", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("transient_storage", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("log", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : + forall (BLOCK TX CFG : Ty.t), + M.IsAssociatedFunction (Self BLOCK TX CFG) "new" (new BLOCK TX CFG). + + (* + pub fn clear(&mut self) { + self.storage.clear(); + self.log.clear(); + } + *) + Definition clear + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "storage" + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "log" + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_clear : + forall (BLOCK TX CFG : Ty.t), + M.IsAssociatedFunction (Self BLOCK TX CFG) "clear" (clear BLOCK TX CFG). + End Impl_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* type Block = BLOCK; *) + Definition _Block (BLOCK TX CFG : Ty.t) : Ty.t := BLOCK. + + (* + fn block(&self) -> &Self::Block { + &self.block + } + *) + Definition block + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "block" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "revm_context_interface::block::BlockGetter" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Block", InstanceField.Ty (_Block BLOCK TX CFG)); + ("block", InstanceField.Method (block BLOCK TX CFG)) + ]. + End Impl_revm_context_interface_block_BlockGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* type Transaction = TX; *) + Definition _Transaction (BLOCK TX CFG : Ty.t) : Ty.t := TX. + + (* + fn tx(&self) -> &Self::Transaction { + &self.tx + } + *) + Definition tx + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "tx" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Transaction", InstanceField.Ty (_Transaction BLOCK TX CFG)); + ("tx", InstanceField.Method (tx BLOCK TX CFG)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (BLOCK TX CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* type Cfg = CFG; *) + Definition _Cfg (BLOCK TX CFG : Ty.t) : Ty.t := CFG. + + (* + fn cfg(&self) -> &Self::Cfg { + &self.cfg + } + *) + Definition cfg + (BLOCK TX CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self BLOCK TX CFG in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "cfg" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (BLOCK TX CFG : Ty.t), + M.IsTraitInstance + "revm_context_interface::cfg::CfgGetter" + (Self BLOCK TX CFG) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Cfg", InstanceField.Ty (_Cfg BLOCK TX CFG)); + ("cfg", InstanceField.Method (cfg BLOCK TX CFG)) + ]. + End Impl_revm_context_interface_cfg_CfgGetter_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + + Module Impl_revm_context_interface_host_Host_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + Definition Self (TX BLOCK CFG : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::host::dummy::DummyHost") [] [ BLOCK; TX; CFG ]. + + (* + fn load_account_delegated(&mut self, _address: Address) -> Option { + Some(AccountLoad::default()) + } + *) + Definition load_account_delegated + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "revm_context_interface::journaled_state::AccountLoad", + [], + "default", + [] + |), + [] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn block_hash(&mut self, _number: u64) -> Option { + Some(B256::ZERO) + } + *) + Definition block_hash + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _number ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _number := M.alloc (| _number |) in + Value.StructTuple + "core::option::Option::Some" + [ M.read (| M.get_constant (| "alloy_primitives::bits::fixed::ZERO" |) |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn balance(&mut self, _address: Address) -> Option> { + Some(Default::default()) + } + *) + Definition balance + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + [], + "default", + [] + |), + [] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn code(&mut self, _address: Address) -> Option> { + Some(Default::default()) + } + *) + Definition code + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + [], + "default", + [] + |), + [] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn code_hash(&mut self, _address: Address) -> Option> { + Some(Eip7702CodeLoad::new_not_delegated(KECCAK_EMPTY, false)) + } + *) + Definition code_hash + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "new_not_delegated", + [] + |), + [ + M.read (| M.get_constant (| "revm_primitives::KECCAK_EMPTY" |) |); + Value.Bool false + ] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sload(&mut self, _address: Address, index: U256) -> Option> { + match self.storage.entry(index) { + Entry::Occupied(entry) => Some(StateLoad::new( *entry.get(), false)), + Entry::Vacant(entry) => { + entry.insert(U256::ZERO); + Some(StateLoad::new(U256::ZERO, true)) + } + } + } + *) + Definition sload + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + let index := M.alloc (| index |) in + M.read (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "entry", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "storage" + |); + M.read (| index |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Occupied", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "new", + [] + |), + [ + M.read (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::OccupiedEntry") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get", + [] + |), + [ entry ] + |) + |); + Value.Bool false + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Vacant", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::VacantEntry") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ M.read (| entry |); M.read (| M.get_constant (| "ruint::ZERO" |) |) ] + |) + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "new", + [] + |), + [ M.read (| M.get_constant (| "ruint::ZERO" |) |); Value.Bool true ] + |) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sstore( + &mut self, + _address: Address, + index: U256, + value: U256, + ) -> Option> { + let present = self.storage.insert(index, value); + Some(StateLoad { + data: SStoreResult { + original_value: U256::ZERO, + present_value: present.unwrap_or(U256::ZERO), + new_value: value, + }, + is_cold: present.is_none(), + }) + } + *) + Definition sstore + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.read (| + let~ present := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "storage" + |); + M.read (| index |); + M.read (| value |) + ] + |) + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ + ("data", + Value.StructRecord + "revm_context_interface::host::SStoreResult" + [ + ("original_value", M.read (| M.get_constant (| "ruint::ZERO" |) |)); + ("present_value", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "unwrap_or", + [] + |), + [ + M.read (| present |); + M.read (| M.get_constant (| "ruint::ZERO" |) |) + ] + |)); + ("new_value", M.read (| value |)) + ]); + ("is_cold", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "is_none", + [] + |), + [ present ] + |)) + ] + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tload(&mut self, _address: Address, index: U256) -> U256 { + self.transient_storage + .get(&index) + .copied() + .unwrap_or_default() + } + *) + Definition tload + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address; index ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + let index := M.alloc (| index |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "unwrap_or_default", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "copied", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get", + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "transient_storage" + |); + index + ] + |) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tstore(&mut self, _address: Address, index: U256, value: U256) { + self.transient_storage.insert(index, value); + } + *) + Definition tstore + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address; index; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + let index := M.alloc (| index |) in + let value := M.alloc (| value |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "transient_storage" + |); + M.read (| index |); + M.read (| value |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn log(&mut self, log: Log) { + self.log.push(log) + } + *) + Definition log + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::host::dummy::DummyHost", + "log" + |); + M.read (| log |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn selfdestruct( + &mut self, + _address: Address, + _target: Address, + ) -> Option> { + Some(StateLoad::default()) + } + *) + Definition selfdestruct + (TX BLOCK CFG : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self TX BLOCK CFG in + match ε, τ, α with + | [], [], [ self; _address; _target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let _address := M.alloc (| _address |) in + let _target := M.alloc (| _target |) in + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SelfDestructResult" ], + [], + "default", + [] + |), + [] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (TX BLOCK CFG : Ty.t), + M.IsTraitInstance + "revm_context_interface::host::Host" + (Self TX BLOCK CFG) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("load_account_delegated", InstanceField.Method (load_account_delegated TX BLOCK CFG)); + ("block_hash", InstanceField.Method (block_hash TX BLOCK CFG)); + ("balance", InstanceField.Method (balance TX BLOCK CFG)); + ("code", InstanceField.Method (code TX BLOCK CFG)); + ("code_hash", InstanceField.Method (code_hash TX BLOCK CFG)); + ("sload", InstanceField.Method (sload TX BLOCK CFG)); + ("sstore", InstanceField.Method (sstore TX BLOCK CFG)); + ("tload", InstanceField.Method (tload TX BLOCK CFG)); + ("tstore", InstanceField.Method (tstore TX BLOCK CFG)); + ("log", InstanceField.Method (log TX BLOCK CFG)); + ("selfdestruct", InstanceField.Method (selfdestruct TX BLOCK CFG)) + ]. + End Impl_revm_context_interface_host_Host_where_revm_context_interface_transaction_Transaction_TX_where_revm_context_interface_block_Block_BLOCK_where_revm_context_interface_cfg_Cfg_CFG_for_revm_context_interface_host_dummy_DummyHost_BLOCK_TX_CFG. + End dummy. +End host. diff --git a/CoqOfRust/revm/translations/context/interface/journaled_state.json b/CoqOfRust/revm/translations/context/interface/journaled_state.json new file mode 100644 index 000000000..2db5b6029 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/journaled_state.json @@ -0,0 +1,13250 @@ +[ + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "Module": { + "name": "journaled_state", + "body": [ + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "Trait": { + "name": "Journal", + "path": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Database", + { + "Type": [] + } + ], + [ + "FinalOutput", + { + "Type": [] + } + ], + [ + "new", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + "Associated" + ], + "ret": { + "Var": { + "name": "Self" + } + } + } + } + } + } + ], + [ + "db_ref", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ], + [ + "db", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ], + [ + "sload", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "sstore", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "tload", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + } + } + } + } + ], + [ + "tstore", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "log", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "selfdestruct", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "warm_account_and_storage", + { + "Definition": { + "const_params": [], + "ty_params": [ + "impl_IntoIterator_Item___U256_" + ], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Var": { + "name": "impl_IntoIterator_Item___U256_" + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "warm_account", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "warm_precompiles", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "precompile_addresses", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "set_spec_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "touch_account", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "transfer", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "inc_account_nonce", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "load_account", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "load_account_code", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "load_account_delegated", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + } + } + } + } + ], + [ + "set_code_with_hash", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "set_code", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "code", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "hash", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "hash_slow", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "set_code_with_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ], + [ + "clear", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "checkpoint", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "checkpoint_commit", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "checkpoint_revert", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ], + [ + "create_account_checkpoint", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "depth", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "usize" + ] + } + } + } + } + } + } + ], + [ + "finalize", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeEnum": { + "name": "TransferError", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "OutOfFunds", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "OverflowPayment", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CreateCollision", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::journaled_state::TransferError::OutOfFunds" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OutOfFunds" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::journaled_state::TransferError::OverflowPayment" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OverflowPayment" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::journaled_state::TransferError::CreateCollision" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateCollision" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeStructStruct": { + "name": "JournalCheckpoint", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "log_i", + { + "Path": { + "path": [ + "usize" + ] + } + } + ], + [ + "journal_i", + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "JournalCheckpoint" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "log_i" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "log_i" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "journal_i" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "journal_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "log_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "log_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "journal_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "journal_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeStructStruct": { + "name": "StateLoad", + "const_params": [], + "ty_params": [ + "T" + ], + "fields": [ + [ + "data", + { + "Var": { + "name": "T" + } + } + ], + [ + "is_cold", + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StateLoad" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "data" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "is_cold" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "default", + "Default" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [ + { + "Var": { + "name": "T" + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "Deref" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Target", + "snippet": [ + " type Target = T;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "T" + } + } + } + } + } + }, + { + "name": "deref", + "snippet": [ + " fn deref(&self) -> &Self::Target {", + " &self.data", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "trait_ty_params": [], + "items": [ + { + "name": "deref_mut", + "snippet": [ + " fn deref_mut(&mut self) -> &mut Self::Target {", + " &mut self.data", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "items": [ + { + "name": "new", + "snippet": [ + " pub fn new(data: T, is_cold: bool) -> Self {", + " Self { data, is_cold }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "data", + { + "Var": { + "name": "T" + } + }, + null + ], + [ + "is_cold", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "map", + "snippet": [ + " pub fn map(self, f: F) -> StateLoad", + " where", + " F: FnOnce(T) -> B,", + " {", + " StateLoad::new(f(self.data), self.is_cold)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "B", + "F" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + null + ], + [ + "f", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "B" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "B" + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeStructStruct": { + "name": "AccountLoad", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "load", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + } + ], + [ + "is_empty", + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ], + "fields": [ + [ + "load", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_empty", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccountLoad" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "load" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "is_empty" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ], + "fields": [ + [ + "load", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "is_empty", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "Deref" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Target", + "snippet": [ + " type Target = Eip7702CodeLoad<()>;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + } + } + } + } + }, + { + "name": "deref", + "snippet": [ + " fn deref(&self) -> &Self::Target {", + " &self.load", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "trait_ty_params": [], + "items": [ + { + "name": "deref_mut", + "snippet": [ + " fn deref_mut(&mut self) -> &mut Self::Target {", + " &mut self.load", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeStructStruct": { + "name": "Eip7702CodeLoad", + "const_params": [], + "ty_params": [ + "T" + ], + "fields": [ + [ + "state_load", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ], + [ + "is_delegate_account_cold", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_delegate_account_cold", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip7702CodeLoad" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "state_load" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "is_delegate_account_cold" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "default", + "Default" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "is_delegate_account_cold", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "Deref" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Target", + "snippet": [ + " type Target = StateLoad;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + } + } + }, + { + "name": "deref", + "snippet": [ + " fn deref(&self) -> &Self::Target {", + " &self.state_load", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "trait_ty_params": [], + "items": [ + { + "name": "deref_mut", + "snippet": [ + " fn deref_mut(&mut self) -> &mut Self::Target {", + " &mut self.state_load", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "items": [ + { + "name": "new_state_load", + "snippet": [ + " pub fn new_state_load(state_load: StateLoad) -> Self {", + " Self {", + " state_load,", + " is_delegate_account_cold: None,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "state_load", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "state_load", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state_load" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state_load" + } + ], + "kind": "Effectful" + } + } + ], + [ + "is_delegate_account_cold", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + }, + { + "name": "new_not_delegated", + "snippet": [ + " pub fn new_not_delegated(data: T, is_cold: bool) -> Self {", + " Self {", + " state_load: StateLoad::new(data, is_cold),", + " is_delegate_account_cold: None,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "data", + { + "Var": { + "name": "T" + } + }, + null + ], + [ + "is_cold", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_delegate_account_cold", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "into_components", + "snippet": [ + " pub fn into_components(self) -> (T, Eip7702CodeLoad<()>) {", + " let is_cold = self.is_cold;", + " (", + " self.state_load.data,", + " Eip7702CodeLoad {", + " state_load: StateLoad::new((), is_cold),", + " is_delegate_account_cold: self.is_delegate_account_cold,", + " },", + " )", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "state_load" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Tuple": { + "elements": [] + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_delegate_account_cold", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "set_delegate_load", + "snippet": [ + " pub fn set_delegate_load(&mut self, is_delegate_account_cold: bool) {", + " self.is_delegate_account_cold = Some(is_delegate_account_cold);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "is_delegate_account_cold", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_delegate_account_cold", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::journaled_state::Eip7702CodeLoad" + }, + { + "InternalString": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "new", + "snippet": [ + " pub fn new(state_load: StateLoad, is_delegate_account_cold: bool) -> Self {", + " Self {", + " state_load,", + " is_delegate_account_cold: Some(is_delegate_account_cold),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "state_load", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + null + ], + [ + "is_delegate_account_cold", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "body": { + "Let": { + "name": "state_load", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state_load" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_delegate_account_cold", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ], + "fields": [ + [ + "state_load", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state_load" + } + ], + "kind": "Effectful" + } + } + ], + [ + "is_delegate_account_cold", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_delegate_account_cold" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TypeAlias": { + "name": "JournalDBError", + "path": [ + "revm_context_interface", + "journaled_state", + "JournalDBError" + ], + "const_params": [], + "ty_params": [ + "CTX" + ], + "ty": "Associated" + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "Trait": { + "name": "JournalGetter", + "path": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Journal", + { + "Type": [] + } + ], + [ + "journal", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ], + [ + "journal_ref", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Journal", + "snippet": [ + " type Journal = T::Journal;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "journal", + "snippet": [ + " fn journal(&mut self) -> &mut Self::Journal {", + " T::journal(*self)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "journal", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "journal_ref", + "snippet": [ + " fn journal_ref(&self) -> &Self::Journal {", + " T::journal_ref(*self)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "journal_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Journal", + "snippet": [ + " type Journal = T::Journal;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "journal", + "snippet": [ + " fn journal(&mut self) -> &mut Self::Journal {", + " T::journal(self.as_mut())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "journal", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "AsMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Var": { + "name": "T" + } + } + ], + "method_name": "as_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "journal_ref", + "snippet": [ + " fn journal_ref(&self) -> &Self::Journal {", + " T::journal_ref(self.as_ref())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "journaled_state", + "JournalGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "journal_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "AsRef" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Var": { + "name": "T" + } + } + ], + "method_name": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/journaled_state.v b/CoqOfRust/revm/translations/context/interface/journaled_state.v new file mode 100644 index 000000000..398a05e3f --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/journaled_state.v @@ -0,0 +1,1976 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module journaled_state. + (* Trait *) + Module Journal. + Definition set_code (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; address; code ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let code := M.alloc (| code |) in + M.read (| + let~ hash := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "hash_slow", + [] + |), + [ code ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::Journal", + Self, + [], + "set_code_with_hash", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| code |); M.read (| hash |) ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_set_code : + M.IsProvidedMethod "revm_context_interface::journaled_state::Journal" "set_code" set_code. + End Journal. + + (* + Enum TransferError + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "OutOfFunds"; + item := StructTuple []; + discriminant := None; + }; + { + name := "OverflowPayment"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CreateCollision"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_marker_Copy_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_journaled_state_TransferError. + + Module Impl_core_clone_Clone_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| M.read (| self |) |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_journaled_state_TransferError. + + Module Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::journaled_state::TransferError::OutOfFunds" + |) in + M.alloc (| M.read (| Value.String "OutOfFunds" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::journaled_state::TransferError::OverflowPayment" + |) in + M.alloc (| M.read (| Value.String "OverflowPayment" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::journaled_state::TransferError::CreateCollision" + |) in + M.alloc (| M.read (| Value.String "CreateCollision" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_TransferError. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_TransferError. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::journaled_state::TransferError" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::journaled_state::TransferError" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_TransferError. + + Module Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_TransferError. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::TransferError". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_TransferError. + + (* StructRecord + { + name := "JournalCheckpoint"; + const_params := []; + ty_params := []; + fields := [ ("log_i", Ty.path "usize"); ("journal_i", Ty.path "usize") ]; + } *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "JournalCheckpoint" |); + M.read (| Value.String "log_i" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "log_i" + |); + M.read (| Value.String "journal_i" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "journal_i" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_JournalCheckpoint. + + Module Impl_core_marker_Copy_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_journaled_state_JournalCheckpoint. + + Module Impl_core_clone_Clone_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.read (| self |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_journaled_state_JournalCheckpoint. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_JournalCheckpoint. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "log_i" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "log_i" + |) + |) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "journal_i" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::JournalCheckpoint", + "journal_i" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_JournalCheckpoint. + + Module Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_JournalCheckpoint. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::JournalCheckpoint". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_JournalCheckpoint. + + (* StructRecord + { + name := "StateLoad"; + const_params := []; + ty_params := [ "T" ]; + fields := [ ("data", T); ("is_cold", Ty.path "bool") ]; + } *) + + Module Impl_core_clone_Clone_where_core_clone_Clone_T_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* Clone *) + Definition clone (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ + ("data", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", T, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + ] + |)); + ("is_cold", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone T)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_T_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_T_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* Debug *) + Definition fmt (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "StateLoad" |); + M.read (| Value.String "data" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |); + M.read (| Value.String "is_cold" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt T)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_T_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_default_Default_where_core_default_Default_T_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* Default *) + Definition default (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ + ("data", + M.call_closure (| + M.get_trait_method (| "core::default::Default", T, [], "default", [] |), + [] + |)); + ("is_cold", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "bool", + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::default::Default" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method (default T)) ]. + End Impl_core_default_Default_where_core_default_Default_T_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* PartialEq *) + Definition eq (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + ] + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq T)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_T_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method (assert_receiver_is_total_eq T)) ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_T_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* type Target = T; *) + Definition _Target (T : Ty.t) : Ty.t := T. + + (* + fn deref(&self) -> &Self::Target { + &self.data + } + *) + Definition deref (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::ops::deref::Deref" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Target", InstanceField.Ty (_Target T)); ("deref", InstanceField.Method (deref T)) ]. + End Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.data + } + *) + Definition deref_mut (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::ops::deref::DerefMut" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("deref_mut", InstanceField.Method (deref_mut T)) ]. + End Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_StateLoad_T. + + Module Impl_revm_context_interface_journaled_state_StateLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* + pub fn new(data: T, is_cold: bool) -> Self { + Self { data, is_cold } + } + *) + Definition new (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ data; is_cold ] => + ltac:(M.monadic + (let data := M.alloc (| data |) in + let is_cold := M.alloc (| is_cold |) in + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ ("data", M.read (| data |)); ("is_cold", M.read (| is_cold |)) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : forall (T : Ty.t), M.IsAssociatedFunction (Self T) "new" (new T). + + (* + pub fn map(self, f: F) -> StateLoad + where + F: FnOnce(T) -> B, + { + StateLoad::new(f(self.data), self.is_cold) + } + *) + Definition map (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [ B; F ], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ B ], + "new", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ T ] ], + "call_once", + [] + |), + [ + M.read (| f |); + Value.Tuple + [ + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |) + ] + ] + |); + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_map : forall (T : Ty.t), M.IsAssociatedFunction (Self T) "map" (map T). + End Impl_revm_context_interface_journaled_state_StateLoad_T. + + (* StructRecord + { + name := "AccountLoad"; + const_params := []; + ty_params := []; + fields := + [ + ("load", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ]); + ("is_empty", Ty.path "bool") + ]; + } *) + + Module Impl_core_clone_Clone_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::journaled_state::AccountLoad" + [ + ("load", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |) + ] + |)); + ("is_empty", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "is_empty" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "AccountLoad" |); + M.read (| Value.String "load" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |); + M.read (| Value.String "is_empty" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "is_empty" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_default_Default_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* Default *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::journaled_state::AccountLoad" + [ + ("load", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ], + [], + "default", + [] + |), + [] + |)); + ("is_empty", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "bool", + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ], + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |) + ] + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "is_empty" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::AccountLoad", + "is_empty" + |) + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* type Target = Eip7702CodeLoad<()>; *) + Definition _Target : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ]. + + (* + fn deref(&self) -> &Self::Target { + &self.load + } + *) + Definition deref (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::ops::deref::Deref" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Target", InstanceField.Ty _Target); ("deref", InstanceField.Method deref) ]. + End Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_AccountLoad. + + Module Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_AccountLoad. + Definition Self : Ty.t := Ty.path "revm_context_interface::journaled_state::AccountLoad". + + (* + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.load + } + *) + Definition deref_mut (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::AccountLoad", + "load" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::ops::deref::DerefMut" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("deref_mut", InstanceField.Method deref_mut) ]. + End Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_AccountLoad. + + (* StructRecord + { + name := "Eip7702CodeLoad"; + const_params := []; + ty_params := [ "T" ]; + fields := + [ + ("state_load", + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]); + ("is_delegate_account_cold", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ]) + ]; + } *) + + Module Impl_core_clone_Clone_where_core_clone_Clone_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* Clone *) + Definition clone (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ T ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |) + ] + |)); + ("is_delegate_account_cold", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone T)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* Debug *) + Definition fmt (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Eip7702CodeLoad" |); + M.read (| Value.String "state_load" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |); + M.read (| Value.String "is_delegate_account_cold" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt T)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_default_Default_where_core_default_Default_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* Default *) + Definition default (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ T ], + [], + "default", + [] + |), + [] + |)); + ("is_delegate_account_cold", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ], + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::default::Default" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method (default T)) ]. + End Impl_core_default_Default_where_core_default_Default_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* PartialEq *) + Definition eq (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ], + [ Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |) + ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ], + [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ] ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq T)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method (assert_receiver_is_total_eq T)) ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_T_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* type Target = StateLoad; *) + Definition _Target (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::StateLoad") [] [ T ]. + + (* + fn deref(&self) -> &Self::Target { + &self.state_load + } + *) + Definition deref (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::ops::deref::Deref" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Target", InstanceField.Ty (_Target T)); ("deref", InstanceField.Method (deref T)) ]. + End Impl_core_ops_deref_Deref_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.state_load + } + *) + Definition deref_mut (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "core::ops::deref::DerefMut" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("deref_mut", InstanceField.Method (deref_mut T)) ]. + End Impl_core_ops_deref_DerefMut_for_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Module Impl_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") [] [ T ]. + + (* + pub fn new_state_load(state_load: StateLoad) -> Self { + Self { + state_load, + is_delegate_account_cold: None, + } + } + *) + Definition new_state_load + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ state_load ] => + ltac:(M.monadic + (let state_load := M.alloc (| state_load |) in + Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", M.read (| state_load |)); + ("is_delegate_account_cold", Value.StructTuple "core::option::Option::None" []) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new_state_load : + forall (T : Ty.t), + M.IsAssociatedFunction (Self T) "new_state_load" (new_state_load T). + + (* + pub fn new_not_delegated(data: T, is_cold: bool) -> Self { + Self { + state_load: StateLoad::new(data, is_cold), + is_delegate_account_cold: None, + } + } + *) + Definition new_not_delegated + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ data; is_cold ] => + ltac:(M.monadic + (let data := M.alloc (| data |) in + let is_cold := M.alloc (| is_cold |) in + Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ T ], + "new", + [] + |), + [ M.read (| data |); M.read (| is_cold |) ] + |)); + ("is_delegate_account_cold", Value.StructTuple "core::option::Option::None" []) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new_not_delegated : + forall (T : Ty.t), + M.IsAssociatedFunction (Self T) "new_not_delegated" (new_not_delegated T). + + (* + pub fn into_components(self) -> (T, Eip7702CodeLoad<()>) { + let is_cold = self.is_cold; + ( + self.state_load.data, + Eip7702CodeLoad { + state_load: StateLoad::new((), is_cold), + is_delegate_account_cold: self.is_delegate_account_cold, + }, + ) + } + *) + Definition into_components + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ is_cold := + M.copy (| + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ T ], + [], + "deref", + [] + |), + [ self ] + |), + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) in + M.alloc (| + Value.Tuple + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "state_load" + |), + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |); + Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.tuple [] ], + "new", + [] + |), + [ Value.Tuple []; M.read (| is_cold |) ] + |)); + ("is_delegate_account_cold", + M.read (| + M.SubPointer.get_struct_record_field (| + self, + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |) + |)) + ] + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_into_components : + forall (T : Ty.t), + M.IsAssociatedFunction (Self T) "into_components" (into_components T). + + (* + pub fn set_delegate_load(&mut self, is_delegate_account_cold: bool) { + self.is_delegate_account_cold = Some(is_delegate_account_cold); + } + *) + Definition set_delegate_load + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; is_delegate_account_cold ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let is_delegate_account_cold := M.alloc (| is_delegate_account_cold |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::journaled_state::Eip7702CodeLoad", + "is_delegate_account_cold" + |), + Value.StructTuple + "core::option::Option::Some" + [ M.read (| is_delegate_account_cold |) ] + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_set_delegate_load : + forall (T : Ty.t), + M.IsAssociatedFunction (Self T) "set_delegate_load" (set_delegate_load T). + + (* + pub fn new(state_load: StateLoad, is_delegate_account_cold: bool) -> Self { + Self { + state_load, + is_delegate_account_cold: Some(is_delegate_account_cold), + } + } + *) + Definition new (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ state_load; is_delegate_account_cold ] => + ltac:(M.monadic + (let state_load := M.alloc (| state_load |) in + let is_delegate_account_cold := M.alloc (| is_delegate_account_cold |) in + Value.StructRecord + "revm_context_interface::journaled_state::Eip7702CodeLoad" + [ + ("state_load", M.read (| state_load |)); + ("is_delegate_account_cold", + Value.StructTuple + "core::option::Option::Some" + [ M.read (| is_delegate_account_cold |) ]) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : forall (T : Ty.t), M.IsAssociatedFunction (Self T) "new" (new T). + End Impl_revm_context_interface_journaled_state_Eip7702CodeLoad_T. + + Axiom JournalDBError : + forall (CTX : Ty.t), + (Ty.apply (Ty.path "revm_context_interface::journaled_state::JournalDBError") [] [ CTX ]) = + Ty.associated. + + (* Trait *) + (* Empty module 'JournalGetter' *) + + Module Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_context_interface_journaled_state_JournalGetter_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* type Journal = T::Journal; *) + Definition _Journal (T : Ty.t) : Ty.t := Ty.associated. + + (* + fn journal(&mut self) -> &mut Self::Journal { + T::journal( *self) + } + *) + Definition journal (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::JournalGetter", + T, + [], + "journal", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn journal_ref(&self) -> &Self::Journal { + T::journal_ref( *self) + } + *) + Definition journal_ref (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::JournalGetter", + T, + [], + "journal_ref", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::journaled_state::JournalGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Journal", InstanceField.Ty (_Journal T)); + ("journal", InstanceField.Method (journal T)); + ("journal_ref", InstanceField.Method (journal_ref T)) + ]. + End Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_context_interface_journaled_state_JournalGetter_T_for_ref_mut_T. + + Module Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_context_interface_journaled_state_JournalGetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* type Journal = T::Journal; *) + Definition _Journal (T : Ty.t) : Ty.t := Ty.associated. + + (* + fn journal(&mut self) -> &mut Self::Journal { + T::journal(self.as_mut()) + } + *) + Definition journal (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::JournalGetter", + T, + [], + "journal", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::convert::AsMut", + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ], + [ T ], + "as_mut", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn journal_ref(&self) -> &Self::Journal { + T::journal_ref(self.as_ref()) + } + *) + Definition journal_ref (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::journaled_state::JournalGetter", + T, + [], + "journal_ref", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::convert::AsRef", + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ], + [ T ], + "as_ref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::journaled_state::JournalGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Journal", InstanceField.Ty (_Journal T)); + ("journal", InstanceField.Method (journal T)); + ("journal_ref", InstanceField.Method (journal_ref T)) + ]. + End Impl_revm_context_interface_journaled_state_JournalGetter_where_revm_context_interface_journaled_state_JournalGetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. +End journaled_state. diff --git a/CoqOfRust/revm/translations/context/interface/result.json b/CoqOfRust/revm/translations/context/interface/result.json new file mode 100644 index 000000000..18c26d2c3 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/result.json @@ -0,0 +1,52298 @@ +[ + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Module": { + "name": "result", + "body": [ + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Trait": { + "name": "HaltReasonTrait", + "path": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "const_params": [], + "ty_params": [], + "body": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "core", + "convert", + "From" + ], + "ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Var": { + "name": "HaltReasonT" + } + }, + "of_trait": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeStructStruct": { + "name": "ResultAndState", + "const_params": [], + "ty_params": [ + "HaltReasonT" + ], + "fields": [ + [ + "result", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "ResultAndState" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "result" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "result" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "state" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ], + "fields": [ + [ + "result", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "result" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "result" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "result" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context_interface::result::ResultAndState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ResultAndState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "ExecutionResult", + "const_params": [], + "ty_params": [ + "HaltReasonT" + ], + "variants": [ + { + "name": "Success", + "item": { + "Struct": { + "fields": [ + [ + "reason", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "gas_used", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "gas_refunded", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "logs", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "output", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "Revert", + "item": { + "Struct": { + "fields": [ + [ + "gas_used", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "output", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "Halt", + "item": { + "Struct": { + "fields": [ + [ + "reason", + { + "Var": { + "name": "HaltReasonT" + } + } + ], + [ + "gas_used", + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_refunded" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult", + "Success" + ], + "fields": [ + [ + "reason", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_used", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_refunded", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "logs", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_3" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "output", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_4" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult", + "Revert" + ], + "fields": [ + [ + "gas_used", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "output", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult", + "Halt" + ], + "fields": [ + [ + "reason", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "HaltReasonT" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_used", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_refunded" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field5_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Success" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "reason" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_used" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_refunded" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "logs" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_3" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "output" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_4" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Revert" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_used" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "output" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Halt" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "reason" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_used" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_refunded" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_refunded" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_2" + }, + { + "LocalVar": "__arg1_2" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_3" + }, + { + "LocalVar": "__arg1_3" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_4" + }, + { + "LocalVar": "__arg1_4" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "unreachable" + ], + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "hash", + "Hash" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "result", + "HaltReasonTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "HaltReasonT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_refunded" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_3" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_4" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "reason" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Var": { + "name": "HaltReasonT" + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "HaltReasonT" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + "items": [ + { + "name": "is_success", + "snippet": [ + " pub fn is_success(&self) -> bool {", + " matches!(self, Self::Success { .. })", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "created_address", + "snippet": [ + " pub fn created_address(&self) -> Option
{", + " match self {", + " Self::Success { output, .. } => output.address().cloned(),", + " _ => None,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "cloned", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "is_halt", + "snippet": [ + " pub fn is_halt(&self) -> bool {", + " matches!(self, Self::Halt { .. })", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "output", + "snippet": [ + " pub fn output(&self) -> Option<&Bytes> {", + " match self {", + " Self::Success { output, .. } => Some(output.data()),", + " Self::Revert { output, .. } => Some(output),", + " _ => None,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "data", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "into_output", + "snippet": [ + " pub fn into_output(self) -> Option {", + " match self {", + " Self::Success { output, .. } => Some(output.into_data()),", + " Self::Revert { output, .. } => Some(output),", + " _ => None,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "into_data", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "output" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "output", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "output" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "logs", + "snippet": [ + " pub fn logs(&self) -> &[Log] {", + " match self {", + " Self::Success { logs, .. } => logs.as_slice(),", + " _ => &[],", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "logs", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_slice", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "into_logs", + "snippet": [ + " pub fn into_logs(self) -> Vec {", + " match self {", + " Self::Success { logs, .. } => logs,", + " _ => Vec::new(),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "logs", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "logs" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "gas_used", + "snippet": [ + " pub fn gas_used(&self) -> u64 {", + " match *self {", + " Self::Success { gas_used, .. }", + " | Self::Revert { gas_used, .. }", + " | Self::Halt { gas_used, .. } => gas_used,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "ExecutionResult" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "HaltReasonT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.find_or_pattern" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "Array": { + "elements": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Success" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "gas_used", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "LocalVar": "gas_used" + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Revert" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "gas_used", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "LocalVar": "gas_used" + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::ExecutionResult::Halt" + }, + { + "InternalString": "gas_used" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "gas_used", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "LocalVar": "gas_used" + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ], + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "gas_used", + null + ] + ], + "body": { + "LocalVar": "gas_used" + }, + "is_for_match": true, + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "Output", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Call", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Create", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Call" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Create" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "Output", + "Call" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "Output", + "Create" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "unreachable" + ], + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "into_data", + "snippet": [ + " pub fn into_data(self) -> Bytes {", + " match self {", + " Output::Call(data) => data,", + " Output::Create(data, _) => data,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "data" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "data" + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "data", + "snippet": [ + " pub fn data(&self) -> &Bytes {", + " match self {", + " Output::Call(data) => data,", + " Output::Create(data, _) => data,", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "data", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "address", + "snippet": [ + " pub fn address(&self) -> Option<&Address> {", + " match self {", + " Output::Call(_) => None,", + " Output::Create(_, address) => address.as_ref(),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "Output" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::Output::Create" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "as_ref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "EVMError", + "const_params": [], + "ty_params": [ + "DBError", + "TransactionError" + ], + "variants": [ + { + "name": "Transaction", + "item": { + "Tuple": { + "tys": [ + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Header", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Database", + "item": { + "Tuple": { + "tys": [ + { + "Var": { + "name": "DBError" + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Custom", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Precompile", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionError" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TransactionError" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Transaction" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Header" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Database" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Custom" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Precompile" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionError" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TransactionError" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Transaction" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "TransactionError" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Header" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Database" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "DBError" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Custom" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Precompile" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionError" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionError" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "TransactionError" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "unreachable" + ], + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionError" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TransactionError" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionError" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TX" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "DBErrorMarker" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TX" + } + } + ] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Var": { + "name": "DBError" + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(value: DBError) -> Self {", + " Self::Database(value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Var": { + "name": "DBError" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TX" + } + } + ] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Database" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Trait": { + "name": "FromStringError", + "path": [ + "revm_context_interface", + "result", + "FromStringError" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "from_string", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "ret": { + "Var": { + "name": "Self" + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB", + "TX" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "TX" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "result", + "FromStringError" + ], + "trait_ty_params": [], + "items": [ + { + "name": "from_string", + "snippet": [ + " fn from_string(value: String) -> Self {", + " Self::Custom(value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + }, + { + "Var": { + "name": "TX" + } + } + ] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Custom" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(value: InvalidTransaction) -> Self {", + " Self::Transaction(value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Transaction" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionValidationErrorT" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "items": [ + { + "name": "map_db_err", + "snippet": [ + " pub fn map_db_err(self, op: F) -> EVMError", + " where", + " F: FnOnce(DBError) -> E,", + " {", + " match self {", + " Self::Transaction(e) => EVMError::Transaction(e),", + " Self::Header(e) => EVMError::Header(e),", + " Self::Database(e) => EVMError::Database(op(e)),", + " Self::Precompile(e) => EVMError::Precompile(e),", + " Self::Custom(e) => EVMError::Custom(e),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "F", + "E" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + null + ], + [ + "op", + { + "Var": { + "name": "F" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "E" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "op", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "op" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Transaction" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Header" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Database" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "function", + "FnOnce" + ], + "self_ty": { + "Var": { + "name": "F" + } + }, + "trait_tys": [ + { + "Tuple": { + "tys": [ + { + "Var": { + "name": "DBError" + } + } + ] + } + } + ], + "method_name": "call_once", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "op" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Precompile" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Custom" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionValidationErrorT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "error", + "Error" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "error", + "Error" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TransactionValidationErrorT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "of_trait": [ + "core", + "error", + "Error" + ], + "trait_ty_params": [], + "items": [ + { + "name": "source", + "snippet": [ + " fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {", + " match self {", + " Self::Transaction(e) => Some(e),", + " Self::Header(e) => Some(e),", + " Self::Database(e) => Some(e),", + " Self::Precompile(_) | Self::Custom(_) => None,", + " }", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "core", + "error", + "Error", + "Trait" + ] + ] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.find_or_pattern" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "Array": { + "elements": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ], + "is_internal": true + } + }, + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "type_id", + "snippet": null, + "kind": "Default" + }, + { + "name": "description", + "snippet": null, + "kind": "Default" + }, + { + "name": "cause", + "snippet": null, + "kind": "Default" + }, + { + "name": "provide", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionValidationErrorT" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Display" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DBError" + } + } + }, + { + "bound": { + "name": [ + "core", + "fmt", + "Display" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "TransactionValidationErrorT" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Display" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + " fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {", + " match self {", + " Self::Transaction(e) => write!(f, \"transaction validation error: {e}\"),", + " Self::Header(e) => write!(f, \"header validation error: {e}\"),", + " Self::Database(e) => write!(f, \"database error: {e}\"),", + " Self::Precompile(e) | Self::Custom(e) => f.write_str(e),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Transaction" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "transaction validation error: " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Header" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "header validation error: " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Database" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "database error: " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.find_or_pattern" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "Array": { + "elements": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Precompile" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "LocalVar": "e" + } + ] + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::EVMError::Custom" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "e", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "LocalVar": "e" + } + ] + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ], + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "e", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "string", + "String" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "e" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DBError", + "TransactionValidationErrorT" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(value: InvalidHeader) -> Self {", + " Self::Header(value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "EVMError" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DBError" + } + }, + { + "Var": { + "name": "TransactionValidationErrorT" + } + } + ] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "EVMError", + "Header" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "InvalidTransaction", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "PriorityFeeGreaterThanMaxFee", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "GasPriceLessThanBasefee", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CallerGasLimitMoreThanBlock", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CallGasCostMoreThanGasLimit", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "RejectCallerWithCode", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "LackOfFundForMaxFee", + "item": { + "Struct": { + "fields": [ + [ + "fee", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "OverflowPaymentInTransaction", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "NonceOverflowInTransaction", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "NonceTooHigh", + "item": { + "Struct": { + "fields": [ + [ + "tx", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "state", + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "NonceTooLow", + "item": { + "Struct": { + "fields": [ + [ + "tx", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "state", + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "CreateInitCodeSizeLimit", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidChainId", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "AccessListNotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "MaxFeePerBlobGasNotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "BlobVersionedHashesNotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "BlobGasPriceGreaterThanMax", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EmptyBlobs", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "BlobCreateTransaction", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "TooManyBlobs", + "item": { + "Struct": { + "fields": [ + [ + "max", + { + "Path": { + "path": [ + "usize" + ] + } + } + ], + [ + "have", + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "BlobVersionNotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EofCrateShouldHaveToAddress", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "AuthorizationListNotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "AuthorizationListInvalidFields", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EmptyAuthorizationList", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidAuthorizationList", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Eip2930NotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip1559NotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip4844NotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip7702NotSupported", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "PriorityFeeGreaterThanMaxFee" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "GasPriceLessThanBasefee" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CallerGasLimitMoreThanBlock" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CallGasCostMoreThanGasLimit" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "RejectCallerWithCode" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "LackOfFundForMaxFee" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "fee" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "balance" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OverflowPaymentInTransaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NonceOverflowInTransaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NonceTooHigh" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "tx" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "state" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NonceTooLow" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "tx" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "state" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateInitCodeSizeLimit" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidChainId" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccessListNotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "MaxFeePerBlobGasNotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlobVersionedHashesNotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlobGasPriceGreaterThanMax" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EmptyBlobs" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlobCreateTransaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "TooManyBlobs" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "max" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "have" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BlobVersionNotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EofCrateShouldHaveToAddress" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AuthorizationListNotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AuthorizationListInvalidFields" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EmptyAuthorizationList" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidAuthorizationList" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip2930NotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip1559NotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip4844NotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip7702NotSupported" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "PriorityFeeGreaterThanMaxFee" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "GasPriceLessThanBasefee" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "CallerGasLimitMoreThanBlock" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "CallGasCostMoreThanGasLimit" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "RejectCallerWithCode" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "LackOfFundForMaxFee" + ], + "fields": [ + [ + "fee", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "balance", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "OverflowPaymentInTransaction" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "NonceOverflowInTransaction" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "NonceTooHigh" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "NonceTooLow" + ], + "fields": [ + [ + "tx", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "CreateInitCodeSizeLimit" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "InvalidChainId" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "AccessListNotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "MaxFeePerBlobGasNotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "BlobVersionedHashesNotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "BlobGasPriceGreaterThanMax" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "EmptyBlobs" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "BlobCreateTransaction" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "TooManyBlobs" + ], + "fields": [ + [ + "max", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "have", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "BlobVersionNotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "EofCrateShouldHaveToAddress" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "AuthorizationListNotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "AuthorizationListInvalidFields" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "EmptyAuthorizationList" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "InvalidAuthorizationList" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "Eip2930NotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "Eip1559NotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "Eip4844NotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "Eip7702NotSupported" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionError" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(value: InvalidAuthorization) -> Self {", + " Self::InvalidAuthorizationList(value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction", + "InvalidAuthorizationList" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "error", + "Error" + ], + "trait_ty_params": [], + "items": [ + { + "name": "source", + "snippet": null, + "kind": "Default" + }, + { + "name": "type_id", + "snippet": null, + "kind": "Default" + }, + { + "name": "description", + "snippet": null, + "kind": "Default" + }, + { + "name": "cause", + "snippet": null, + "kind": "Default" + }, + { + "name": "provide", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Display" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + " fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {", + " match self {", + " Self::PriorityFeeGreaterThanMaxFee => {", + " write!(f, \"priority fee is greater than max fee\")", + " }", + " Self::GasPriceLessThanBasefee => {", + " write!(f, \"gas price is less than basefee\")", + " }", + " Self::CallerGasLimitMoreThanBlock => {", + " write!(f, \"caller gas limit exceeds the block gas limit\")", + " }", + " Self::CallGasCostMoreThanGasLimit => {", + " write!(f, \"call gas cost exceeds the gas limit\")", + " }", + " Self::RejectCallerWithCode => {", + " write!(f, \"reject transactions from senders with deployed code\")", + " }", + " Self::LackOfFundForMaxFee { fee, balance } => {", + " write!(f, \"lack of funds ({balance}) for max fee ({fee})\")", + " }", + " Self::OverflowPaymentInTransaction => {", + " write!(f, \"overflow payment in transaction\")", + " }", + " Self::NonceOverflowInTransaction => {", + " write!(f, \"nonce overflow in transaction\")", + " }", + " Self::NonceTooHigh { tx, state } => {", + " write!(f, \"nonce {tx} too high, expected {state}\")", + " }", + " Self::NonceTooLow { tx, state } => {", + " write!(f, \"nonce {tx} too low, expected {state}\")", + " }", + " Self::CreateInitCodeSizeLimit => {", + " write!(f, \"create initcode size limit\")", + " }", + " Self::InvalidChainId => write!(f, \"invalid chain ID\"),", + " Self::AccessListNotSupported => write!(f, \"access list not supported\"),", + " Self::MaxFeePerBlobGasNotSupported => {", + " write!(f, \"max fee per blob gas not supported\")", + " }", + " Self::BlobVersionedHashesNotSupported => {", + " write!(f, \"blob versioned hashes not supported\")", + " }", + " Self::BlobGasPriceGreaterThanMax => {", + " write!(f, \"blob gas price is greater than max fee per blob gas\")", + " }", + " Self::EmptyBlobs => write!(f, \"empty blobs\"),", + " Self::BlobCreateTransaction => write!(f, \"blob create transaction\"),", + " Self::TooManyBlobs { max, have } => {", + " write!(f, \"too many blobs, have {have}, max {max}\")", + " }", + " Self::BlobVersionNotSupported => write!(f, \"blob version not supported\"),", + " Self::EofCrateShouldHaveToAddress => write!(f, \"EOF crate should have `to` address\"),", + " Self::AuthorizationListNotSupported => write!(f, \"authorization list not supported\"),", + " Self::AuthorizationListInvalidFields => {", + " write!(f, \"authorization list tx has invalid fields\")", + " }", + " Self::EmptyAuthorizationList => write!(f, \"empty authorization list\"),", + " Self::Eip2930NotSupported => write!(f, \"Eip2930 is not supported\"),", + " Self::Eip1559NotSupported => write!(f, \"Eip1559 is not supported\"),", + " Self::Eip4844NotSupported => write!(f, \"Eip4844 is not supported\"),", + " Self::Eip7702NotSupported => write!(f, \"Eip7702 is not supported\"),", + " Self::InvalidAuthorizationList(i) => fmt::Display::fmt(i, f),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "priority fee is greater than max fee" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas price is less than basefee" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "caller gas limit exceeds the block gas limit" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "call gas cost exceeds the gas limit" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "reject transactions from senders with deployed code" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "lack of funds (" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": ") for max fee (" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": ")" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "fee" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "overflow payment in transaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "nonce overflow in transaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "nonce " + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": " too high, expected " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "tx" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::NonceTooLow" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "tx", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "nonce " + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": " too low, expected " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "tx" + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "create initcode size limit" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "invalid chain ID" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "access list not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "max fee per blob gas not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob versioned hashes not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob gas price is greater than max fee per blob gas" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "empty blobs" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob create transaction" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "max" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + }, + { + "InternalString": "have" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "max", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "have", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "too many blobs, have " + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": ", max " + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "have" + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "LocalVar": "max" + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob version not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EOF crate should have `to` address" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "authorization list not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "authorization list tx has invalid fields" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "empty authorization list" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip2930 is not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip1559 is not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip4844 is not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip7702 is not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "i", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "fmt", + "Display" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "i" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "InvalidHeader", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "PrevrandaoNotSet", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "ExcessBlobGasNotSet", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidHeader::PrevrandaoNotSet" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "PrevrandaoNotSet" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidHeader::ExcessBlobGasNotSet" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "ExcessBlobGasNotSet" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "error", + "Error" + ], + "trait_ty_params": [], + "items": [ + { + "name": "source", + "snippet": null, + "kind": "Default" + }, + { + "name": "type_id", + "snippet": null, + "kind": "Default" + }, + { + "name": "description", + "snippet": null, + "kind": "Default" + }, + { + "name": "cause", + "snippet": null, + "kind": "Default" + }, + { + "name": "provide", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Display" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + " fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {", + " match self {", + " Self::PrevrandaoNotSet => write!(f, \"`prevrandao` not set\"),", + " Self::ExcessBlobGasNotSet => write!(f, \"`excess_blob_gas` not set\"),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidHeader" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidHeader::PrevrandaoNotSet" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "`prevrandao` not set" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::InvalidHeader::ExcessBlobGasNotSet" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "`excess_blob_gas` not set" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "SuccessReason", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Stop", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Return", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "SelfDestruct", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EofReturnContract", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::SuccessReason::Stop" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Stop" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::SuccessReason::Return" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Return" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::SuccessReason::SelfDestruct" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SelfDestruct" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::SuccessReason::EofReturnContract" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EofReturnContract" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "SuccessReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "HaltReason", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "OutOfGas", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "OpcodeNotFound", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidFEOpcode", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidJump", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "NotActivated", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "StackUnderflow", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "StackOverflow", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "OutOfOffset", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CreateCollision", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "PrecompileError", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "NonceOverflow", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CreateContractSizeLimit", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CreateContractStartingWithEF", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CreateInitCodeSizeLimit", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "OverflowPayment", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "StateChangeDuringStaticCall", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CallNotAllowedInsideStatic", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "OutOfFunds", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CallTooDeep", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EofAuxDataOverflow", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "EofAuxDataTooSmall", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "SubRoutineStackOverflow", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidEXTCALLTarget", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfGas" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OutOfGas" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OpcodeNotFound" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OpcodeNotFound" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::InvalidFEOpcode" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidFEOpcode" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::InvalidJump" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidJump" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::NotActivated" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NotActivated" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::StackUnderflow" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StackUnderflow" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::StackOverflow" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StackOverflow" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfOffset" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OutOfOffset" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CreateCollision" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateCollision" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::PrecompileError" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "PrecompileError" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::NonceOverflow" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NonceOverflow" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CreateContractSizeLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateContractSizeLimit" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CreateContractStartingWithEF" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateContractStartingWithEF" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CreateInitCodeSizeLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CreateInitCodeSizeLimit" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OverflowPayment" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OverflowPayment" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::StateChangeDuringStaticCall" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StateChangeDuringStaticCall" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CallNotAllowedInsideStatic" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CallNotAllowedInsideStatic" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfFunds" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OutOfFunds" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::CallTooDeep" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CallTooDeep" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::EofAuxDataOverflow" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EofAuxDataOverflow" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::EofAuxDataTooSmall" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "EofAuxDataTooSmall" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::SubRoutineStackOverflow" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SubRoutineStackOverflow" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::InvalidEXTCALLTarget" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidEXTCALLTarget" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfGas" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfGas" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "HaltReason" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::HaltReason::OutOfGas" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TypeEnum": { + "name": "OutOfGasError", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Basic", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "MemoryLimit", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Memory", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Precompile", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidOperand", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "ReentrancySentry", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::Basic" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Basic" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::MemoryLimit" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "MemoryLimit" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::Memory" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Memory" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::Precompile" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Precompile" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::InvalidOperand" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidOperand" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::result::OutOfGasError::ReentrancySentry" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "ReentrancySentry" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/result.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "OutOfGasError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/result.v b/CoqOfRust/revm/translations/context/interface/result.v new file mode 100644 index 000000000..60dbeb184 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/result.v @@ -0,0 +1,9146 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module result. + (* Trait *) + (* Empty module 'HaltReasonTrait' *) + + Module Impl_revm_context_interface_result_HaltReasonTrait_where_core_clone_Clone_HaltReasonT_where_core_fmt_Debug_HaltReasonT_where_core_cmp_PartialEq_HaltReasonT_where_core_cmp_Eq_HaltReasonT_where_core_convert_From_HaltReasonT_revm_context_interface_result_HaltReason_for_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := HaltReasonT. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "revm_context_interface::result::HaltReasonTrait" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_revm_context_interface_result_HaltReasonTrait_where_core_clone_Clone_HaltReasonT_where_core_fmt_Debug_HaltReasonT_where_core_cmp_PartialEq_HaltReasonT_where_core_cmp_Eq_HaltReasonT_where_core_convert_From_HaltReasonT_revm_context_interface_result_HaltReason_for_HaltReasonT. + + (* StructRecord + { + name := "ResultAndState"; + const_params := []; + ty_params := [ "HaltReasonT" ]; + fields := + [ + ("result", + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ]); + ("state", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]) + ]; + } *) + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ResultAndState") [] [ HaltReasonT ]. + + (* Debug *) + Definition fmt (HaltReasonT : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "ResultAndState" |); + M.read (| Value.String "result" |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "result" + |); + M.read (| Value.String "state" |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "state" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt HaltReasonT)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + + Module Impl_core_clone_Clone_where_core_clone_Clone_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ResultAndState") [] [ HaltReasonT ]. + + (* Clone *) + Definition clone + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context_interface::result::ResultAndState" + [ + ("result", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "result" + |) + ] + |)); + ("state", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "state" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone HaltReasonT)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + + Module Impl_core_marker_StructuralPartialEq_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ResultAndState") [] [ HaltReasonT ]. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ResultAndState") [] [ HaltReasonT ]. + + (* PartialEq *) + Definition eq (HaltReasonT : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ], + [ + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "result" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::result::ResultAndState", + "result" + |) + ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context_interface::result::ResultAndState", + "state" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context_interface::result::ResultAndState", + "state" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq HaltReasonT)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ResultAndState") [] [ HaltReasonT ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("assert_receiver_is_total_eq", + InstanceField.Method (assert_receiver_is_total_eq HaltReasonT)) + ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ResultAndState_HaltReasonT. + + (* + Enum ExecutionResult + { + const_params := []; + ty_params := [ "HaltReasonT" ]; + variants := + [ + { + name := "Success"; + item := + StructRecord + [ + ("reason", Ty.path "revm_context_interface::result::SuccessReason"); + ("gas_used", Ty.path "u64"); + ("gas_refunded", Ty.path "u64"); + ("logs", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ]); + ("output", Ty.path "revm_context_interface::result::Output") + ]; + discriminant := None; + }; + { + name := "Revert"; + item := + StructRecord + [ ("gas_used", Ty.path "u64"); ("output", Ty.path "alloy_primitives::bytes_::Bytes") + ]; + discriminant := None; + }; + { + name := "Halt"; + item := StructRecord [ ("reason", HaltReasonT); ("gas_used", Ty.path "u64") ]; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_clone_Clone_where_core_clone_Clone_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* Clone *) + Definition clone + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_refunded" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + let __self_4 := M.alloc (| γ1_4 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::ExecutionResult::Success" + [ + ("reason", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "revm_context_interface::result::SuccessReason", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("gas_used", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)); + ("gas_refunded", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_2 |) ] + |)); + ("logs", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ M.read (| __self_3 |) ] + |)); + ("output", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "revm_context_interface::result::Output", + [], + "clone", + [] + |), + [ M.read (| __self_4 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::ExecutionResult::Revert" + [ + ("gas_used", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("output", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::ExecutionResult::Halt" + [ + ("reason", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + HaltReasonT, + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("gas_used", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone HaltReasonT)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* Debug *) + Definition fmt (HaltReasonT : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_refunded" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + let __self_4 := M.alloc (| γ1_4 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field5_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Success" |); + M.read (| Value.String "reason" |); + M.read (| __self_0 |); + M.read (| Value.String "gas_used" |); + M.read (| __self_1 |); + M.read (| Value.String "gas_refunded" |); + M.read (| __self_2 |); + M.read (| Value.String "logs" |); + M.read (| __self_3 |); + M.read (| Value.String "output" |); + __self_4 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Revert" |); + M.read (| Value.String "gas_used" |); + M.read (| __self_0 |); + M.read (| Value.String "output" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Halt" |); + M.read (| Value.String "reason" |); + M.read (| __self_0 |); + M.read (| Value.String "gas_used" |); + __self_1 + ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt HaltReasonT)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_core_marker_StructuralPartialEq_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* PartialEq *) + Definition eq (HaltReasonT : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ] + ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ] + ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Success", + "reason" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Success", + "gas_refunded" + |) in + let γ2_3 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let γ2_4 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let __self_2 := M.alloc (| γ2_2 |) in + let __self_3 := M.alloc (| γ2_3 |) in + let __self_4 := M.alloc (| γ2_4 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Success", + "reason" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Success", + "gas_refunded" + |) in + let γ2_3 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let γ2_4 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + let __arg1_2 := M.alloc (| γ2_2 |) in + let __arg1_3 := M.alloc (| γ2_3 |) in + let __arg1_4 := M.alloc (| γ2_4 |) in + M.alloc (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_context_interface::result::SuccessReason" + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_context_interface::result::SuccessReason" + ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_2; __arg1_2 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "eq", + [] + |), + [ __self_3; __arg1_3 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::Output" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::Output" ] + ], + "eq", + [] + |), + [ __self_4; __arg1_4 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Halt", + "reason" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Halt", + "reason" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ HaltReasonT ], + [ Ty.apply (Ty.path "&") [] [ HaltReasonT ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::intrinsics::unreachable", [] |), + [] + |) + |) + |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq HaltReasonT)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("assert_receiver_is_total_eq", + InstanceField.Method (assert_receiver_is_total_eq HaltReasonT)) + ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_core_hash_Hash_where_core_hash_Hash_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* Hash *) + Definition hash + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.apply + (Ty.path "revm_context_interface::result::ExecutionResult") + [] + [ HaltReasonT ] + ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_refunded" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + let __self_4 := M.alloc (| γ1_4 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "revm_context_interface::result::SuccessReason", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_2 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_3 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "revm_context_interface::result::Output", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_4 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "reason" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + HaltReasonT, + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (HaltReasonT : Ty.t), + M.IsTraitInstance + "core::hash::Hash" + (Self HaltReasonT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method (hash HaltReasonT)) ]. + End Impl_core_hash_Hash_where_core_hash_Hash_HaltReasonT_where_revm_context_interface_result_HaltReasonTrait_HaltReasonT_for_revm_context_interface_result_ExecutionResult_HaltReasonT. + + Module Impl_revm_context_interface_result_ExecutionResult_HaltReasonT. + Definition Self (HaltReasonT : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::ExecutionResult") [] [ HaltReasonT ]. + + (* + pub fn is_success(&self) -> bool { + matches!(self, Self::Success { .. }) + } + *) + Definition is_success + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::ExecutionResult::Success" + |) in + M.alloc (| Value.Bool true |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_success : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "is_success" (is_success HaltReasonT). + + (* + pub fn created_address(&self) -> Option
{ + match self { + Self::Success { output, .. } => output.address().cloned(), + _ => None, + } + } + *) + Definition created_address + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let output := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "cloned", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_context_interface::result::Output", + "address", + [] + |), + [ M.read (| output |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.StructTuple "core::option::Option::None" [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_created_address : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "created_address" (created_address HaltReasonT). + + (* + pub fn is_halt(&self) -> bool { + matches!(self, Self::Halt { .. }) + } + *) + Definition is_halt + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::ExecutionResult::Halt" + |) in + M.alloc (| Value.Bool true |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_is_halt : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "is_halt" (is_halt HaltReasonT). + + (* + pub fn output(&self) -> Option<&Bytes> { + match self { + Self::Success { output, .. } => Some(output.data()), + Self::Revert { output, .. } => Some(output), + _ => None, + } + } + *) + Definition output + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let output := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_context_interface::result::Output", + "data", + [] + |), + [ M.read (| output |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let output := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple "core::option::Option::Some" [ M.read (| output |) ] + |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.StructTuple "core::option::Option::None" [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_output : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "output" (output HaltReasonT). + + (* + pub fn into_output(self) -> Option { + match self { + Self::Success { output, .. } => Some(output.into_data()), + Self::Revert { output, .. } => Some(output), + _ => None, + } + } + *) + Definition into_output + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "output" + |) in + let output := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_context_interface::result::Output", + "into_data", + [] + |), + [ M.read (| output |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "output" + |) in + let output := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple "core::option::Option::Some" [ M.read (| output |) ] + |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.StructTuple "core::option::Option::None" [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_into_output : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "into_output" (into_output HaltReasonT). + + (* + pub fn logs(&self) -> &[Log] { + match self { + Self::Success { logs, .. } => logs.as_slice(), + _ => &[], + } + } + *) + Definition logs + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let logs := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "as_slice", + [] + |), + [ M.read (| logs |) ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| M.alloc (| Value.Array [] |) |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_logs : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "logs" (logs HaltReasonT). + + (* + pub fn into_logs(self) -> Vec { + match self { + Self::Success { logs, .. } => logs, + _ => Vec::new(), + } + } + *) + Definition into_logs + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "logs" + |) in + let logs := M.copy (| γ0_0 |) in + logs)); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_into_logs : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "into_logs" (into_logs HaltReasonT). + + (* + pub fn gas_used(&self) -> u64 { + match *self { + Self::Success { gas_used, .. } + | Self::Revert { gas_used, .. } + | Self::Halt { gas_used, .. } => gas_used, + } + } + *) + Definition gas_used + (HaltReasonT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self HaltReasonT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + M.read (| self |), + [ + fun γ => + ltac:(M.monadic + (M.find_or_pattern (| + γ, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Success", + "gas_used" + |) in + let gas_used := M.copy (| γ0_0 |) in + Value.Tuple [ gas_used ])); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Revert", + "gas_used" + |) in + let gas_used := M.copy (| γ0_0 |) in + Value.Tuple [ gas_used ])); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::ExecutionResult::Halt", + "gas_used" + |) in + let gas_used := M.copy (| γ0_0 |) in + Value.Tuple [ gas_used ])) + ], + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ gas_used ] => ltac:(M.monadic gas_used) + | _ => M.impossible "wrong number of arguments" + end)) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_gas_used : + forall (HaltReasonT : Ty.t), + M.IsAssociatedFunction (Self HaltReasonT) "gas_used" (gas_used HaltReasonT). + End Impl_revm_context_interface_result_ExecutionResult_HaltReasonT. + + (* + Enum Output + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Call"; + item := StructTuple [ Ty.path "alloy_primitives::bytes_::Bytes" ]; + discriminant := None; + }; + { + name := "Create"; + item := + StructTuple + [ + Ty.path "alloy_primitives::bytes_::Bytes"; + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ]; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Call" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ1_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "Create" |); + M.read (| __self_0 |); + __self_1 + ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_Output. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::Output::Call" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ1_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::Output::Create" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |); + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_Output. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_Output. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::Output" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::Output" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::Output::Call", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::Output::Call", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ2_1 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::Output::Create", + 1 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ2_1 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::Output::Create", + 1 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bytes_::Bytes" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::intrinsics::unreachable", [] |), + [] + |) + |) + |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_Output. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_Output. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::Output" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ1_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_Output. + + Module Impl_revm_context_interface_result_Output. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::Output". + + (* + pub fn into_data(self) -> Bytes { + match self { + Output::Call(data) => data, + Output::Create(data, _) => data, + } + } + *) + Definition into_data (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + let data := M.copy (| γ0_0 |) in + data)); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ0_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let data := M.copy (| γ0_0 |) in + data)) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_into_data : M.IsAssociatedFunction Self "into_data" into_data. + + (* + pub fn data(&self) -> &Bytes { + match self { + Output::Call(data) => data, + Output::Create(data, _) => data, + } + } + *) + Definition data (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + let data := M.alloc (| γ1_0 |) in + M.alloc (| M.read (| data |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ1_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let data := M.alloc (| γ1_0 |) in + M.alloc (| M.read (| data |) |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_data : M.IsAssociatedFunction Self "data" data. + + (* + pub fn address(&self) -> Option<&Address> { + match self { + Output::Call(_) => None, + Output::Create(_, address) => address.as_ref(), + } + } + *) + Definition address (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Call", + 0 + |) in + M.alloc (| Value.StructTuple "core::option::Option::None" [] |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 0 + |) in + let γ1_1 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::Output::Create", + 1 + |) in + let address := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + "as_ref", + [] + |), + [ M.read (| address |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_address : M.IsAssociatedFunction Self "address" address. + End Impl_revm_context_interface_result_Output. + + (* + Enum EVMError + { + const_params := []; + ty_params := [ "DBError"; "TransactionError" ]; + variants := + [ + { + name := "Transaction"; + item := StructTuple [ TransactionError ]; + discriminant := None; + }; + { + name := "Header"; + item := StructTuple [ Ty.path "revm_context_interface::result::InvalidHeader" ]; + discriminant := None; + }; + { + name := "Database"; + item := StructTuple [ DBError ]; + discriminant := None; + }; + { + name := "Custom"; + item := StructTuple [ Ty.path "alloc::string::String" ]; + discriminant := None; + }; + { + name := "Precompile"; + item := StructTuple [ Ty.path "alloc::string::String" ]; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_DBError_where_core_fmt_Debug_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + Definition Self (DBError TransactionError : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ]. + + (* Debug *) + Definition fmt + (DBError TransactionError : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionError in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Transaction" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Header" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Database" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Custom" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "Precompile" |); __self_0 ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionError : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self DBError TransactionError) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt DBError TransactionError)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_DBError_where_core_fmt_Debug_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + + Module Impl_core_clone_Clone_where_core_clone_Clone_DBError_where_core_clone_Clone_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + Definition Self (DBError TransactionError : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ]. + + (* Clone *) + Definition clone + (DBError TransactionError : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionError in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Transaction" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + TransactionError, + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Header" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "revm_context_interface::result::InvalidHeader", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Database" + [ + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", DBError, [], "clone", [] |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Custom" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloc::string::String", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Precompile" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloc::string::String", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionError : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self DBError TransactionError) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone DBError TransactionError)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_DBError_where_core_clone_Clone_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_EVMError_DBError_TransactionError. + Definition Self (DBError TransactionError : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ]. + + Axiom Implements : + forall (DBError TransactionError : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self DBError TransactionError) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_EVMError_DBError_TransactionError. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_DBError_where_core_cmp_PartialEq_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + Definition Self (DBError TransactionError : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ]. + + (* PartialEq *) + Definition eq + (DBError TransactionError : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionError in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ] + ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ] + ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ TransactionError ], + [ Ty.apply (Ty.path "&") [] [ TransactionError ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::InvalidHeader" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::InvalidHeader" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ DBError ], + [ Ty.apply (Ty.path "&") [] [ DBError ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "alloc::string::String" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "alloc::string::String" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "alloc::string::String" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "alloc::string::String" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::intrinsics::unreachable", [] |), + [] + |) + |) + |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionError : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self DBError TransactionError) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq DBError TransactionError)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_DBError_where_core_cmp_PartialEq_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_DBError_where_core_cmp_Eq_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + Definition Self (DBError TransactionError : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionError ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (DBError TransactionError : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionError in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionError : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self DBError TransactionError) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("assert_receiver_is_total_eq", + InstanceField.Method (assert_receiver_is_total_eq DBError TransactionError)) + ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_DBError_where_core_cmp_Eq_TransactionError_for_revm_context_interface_result_EVMError_DBError_TransactionError. + + Module Impl_core_convert_From_where_revm_database_interface_DBErrorMarker_DBError_DBError_for_revm_context_interface_result_EVMError_DBError_TX. + Definition Self (DBError TX : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::EVMError") [] [ DBError; TX ]. + + (* + fn from(value: DBError) -> Self { + Self::Database(value) + } + *) + Definition from (DBError TX : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DBError TX in + match ε, τ, α with + | [], [], [ value ] => + ltac:(M.monadic + (let value := M.alloc (| value |) in + Value.StructTuple + "revm_context_interface::result::EVMError::Database" + [ M.read (| value |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TX : Ty.t), + M.IsTraitInstance + "core::convert::From" + (Self DBError TX) + (* Trait polymorphic types *) [ (* T *) DBError ] + (* Instance *) [ ("from", InstanceField.Method (from DBError TX)) ]. + End Impl_core_convert_From_where_revm_database_interface_DBErrorMarker_DBError_DBError_for_revm_context_interface_result_EVMError_DBError_TX. + + (* Trait *) + (* Empty module 'FromStringError' *) + + Module Impl_revm_context_interface_result_FromStringError_for_revm_context_interface_result_EVMError_DB_TX. + Definition Self (DB TX : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context_interface::result::EVMError") [] [ DB; TX ]. + + (* + fn from_string(value: String) -> Self { + Self::Custom(value) + } + *) + Definition from_string + (DB TX : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB TX in + match ε, τ, α with + | [], [], [ value ] => + ltac:(M.monadic + (let value := M.alloc (| value |) in + Value.StructTuple + "revm_context_interface::result::EVMError::Custom" + [ M.read (| value |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB TX : Ty.t), + M.IsTraitInstance + "revm_context_interface::result::FromStringError" + (Self DB TX) + (* Trait polymorphic types *) [] + (* Instance *) [ ("from_string", InstanceField.Method (from_string DB TX)) ]. + End Impl_revm_context_interface_result_FromStringError_for_revm_context_interface_result_EVMError_DB_TX. + + Module Impl_core_convert_From_revm_context_interface_result_InvalidTransaction_for_revm_context_interface_result_EVMError_DB_revm_context_interface_result_InvalidTransaction. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DB; Ty.path "revm_context_interface::result::InvalidTransaction" ]. + + (* + fn from(value: InvalidTransaction) -> Self { + Self::Transaction(value) + } + *) + Definition from (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ value ] => + ltac:(M.monadic + (let value := M.alloc (| value |) in + Value.StructTuple + "revm_context_interface::result::EVMError::Transaction" + [ M.read (| value |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::convert::From" + (Self DB) + (* Trait polymorphic types *) + [ (* T *) Ty.path "revm_context_interface::result::InvalidTransaction" ] + (* Instance *) [ ("from", InstanceField.Method (from DB)) ]. + End Impl_core_convert_From_revm_context_interface_result_InvalidTransaction_for_revm_context_interface_result_EVMError_DB_revm_context_interface_result_InvalidTransaction. + + Module Impl_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + Definition Self (DBError TransactionValidationErrorT : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionValidationErrorT ]. + + (* + pub fn map_db_err(self, op: F) -> EVMError + where + F: FnOnce(DBError) -> E, + { + match self { + Self::Transaction(e) => EVMError::Transaction(e), + Self::Header(e) => EVMError::Header(e), + Self::Database(e) => EVMError::Database(op(e)), + Self::Precompile(e) => EVMError::Precompile(e), + Self::Custom(e) => EVMError::Custom(e), + } + } + *) + Definition map_db_err + (DBError TransactionValidationErrorT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionValidationErrorT in + match ε, τ, α with + | [], [ F; E ], [ self; op ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let op := M.alloc (| op |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let e := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Transaction" + [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let e := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Header" + [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let e := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Database" + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::function::FnOnce", + F, + [ Ty.tuple [ DBError ] ], + "call_once", + [] + |), + [ M.read (| op |); Value.Tuple [ M.read (| e |) ] ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let e := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Precompile" + [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let e := M.copy (| γ0_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::EVMError::Custom" + [ M.read (| e |) ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_map_db_err : + forall (DBError TransactionValidationErrorT : Ty.t), + M.IsAssociatedFunction + (Self DBError TransactionValidationErrorT) + "map_db_err" + (map_db_err DBError TransactionValidationErrorT). + End Impl_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + + Module Impl_core_error_Error_where_core_error_Error_DBError_where_core_error_Error_TransactionValidationErrorT_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + Definition Self (DBError TransactionValidationErrorT : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionValidationErrorT ]. + + (* + fn source(&self) -> Option<&(dyn core::error::Error + 'static)> { + match self { + Self::Transaction(e) => Some(e), + Self::Header(e) => Some(e), + Self::Database(e) => Some(e), + Self::Precompile(_) | Self::Custom(_) => None, + } + } + *) + Definition source + (DBError TransactionValidationErrorT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionValidationErrorT in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple "core::option::Option::Some" [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple "core::option::Option::Some" [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple "core::option::Option::Some" [ M.read (| e |) ] + |))); + fun γ => + ltac:(M.monadic + (M.find_or_pattern (| + γ, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + Value.Tuple [])); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + Value.Tuple [])) + ], + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [] => + ltac:(M.monadic + (M.alloc (| Value.StructTuple "core::option::Option::None" [] |))) + | _ => M.impossible "wrong number of arguments" + end)) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionValidationErrorT : Ty.t), + M.IsTraitInstance + "core::error::Error" + (Self DBError TransactionValidationErrorT) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("source", InstanceField.Method (source DBError TransactionValidationErrorT)) ]. + End Impl_core_error_Error_where_core_error_Error_DBError_where_core_error_Error_TransactionValidationErrorT_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + + Module Impl_core_fmt_Display_where_core_fmt_Display_DBError_where_core_fmt_Display_TransactionValidationErrorT_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + Definition Self (DBError TransactionValidationErrorT : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionValidationErrorT ]. + + (* + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Transaction(e) => write!(f, "transaction validation error: {e}"), + Self::Header(e) => write!(f, "header validation error: {e}"), + Self::Database(e) => write!(f, "database error: {e}"), + Self::Precompile(e) | Self::Custom(e) => f.write_str(e), + } + } + *) + Definition fmt + (DBError TransactionValidationErrorT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionValidationErrorT in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Transaction", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "transaction validation error: " |) ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ TransactionValidationErrorT ] + ] + |), + [ e ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Header", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "header validation error: " |) ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_context_interface::result::InvalidHeader" + ] + ] + |), + [ e ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Database", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "database error: " |) ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ DBError ] ] + |), + [ e ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (M.find_or_pattern (| + γ, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Precompile", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + Value.Tuple [ e ])); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::EVMError::Custom", + 0 + |) in + let e := M.alloc (| γ1_0 |) in + Value.Tuple [ e ])) + ], + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ e ] => + ltac:(M.monadic + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.path "alloc::string::String", + [], + "deref", + [] + |), + [ M.read (| e |) ] + |) + ] + |) + |))) + | _ => M.impossible "wrong number of arguments" + end)) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionValidationErrorT : Ty.t), + M.IsTraitInstance + "core::fmt::Display" + (Self DBError TransactionValidationErrorT) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt DBError TransactionValidationErrorT)) ]. + End Impl_core_fmt_Display_where_core_fmt_Display_DBError_where_core_fmt_Display_TransactionValidationErrorT_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + + Module Impl_core_convert_From_revm_context_interface_result_InvalidHeader_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + Definition Self (DBError TransactionValidationErrorT : Ty.t) : Ty.t := + Ty.apply + (Ty.path "revm_context_interface::result::EVMError") + [] + [ DBError; TransactionValidationErrorT ]. + + (* + fn from(value: InvalidHeader) -> Self { + Self::Header(value) + } + *) + Definition from + (DBError TransactionValidationErrorT : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DBError TransactionValidationErrorT in + match ε, τ, α with + | [], [], [ value ] => + ltac:(M.monadic + (let value := M.alloc (| value |) in + Value.StructTuple + "revm_context_interface::result::EVMError::Header" + [ M.read (| value |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DBError TransactionValidationErrorT : Ty.t), + M.IsTraitInstance + "core::convert::From" + (Self DBError TransactionValidationErrorT) + (* Trait polymorphic types *) + [ (* T *) Ty.path "revm_context_interface::result::InvalidHeader" ] + (* Instance *) + [ ("from", InstanceField.Method (from DBError TransactionValidationErrorT)) ]. + End Impl_core_convert_From_revm_context_interface_result_InvalidHeader_for_revm_context_interface_result_EVMError_DBError_TransactionValidationErrorT. + + (* + Enum InvalidTransaction + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "PriorityFeeGreaterThanMaxFee"; + item := StructTuple []; + discriminant := None; + }; + { + name := "GasPriceLessThanBasefee"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CallerGasLimitMoreThanBlock"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CallGasCostMoreThanGasLimit"; + item := StructTuple []; + discriminant := None; + }; + { + name := "RejectCallerWithCode"; + item := StructTuple []; + discriminant := None; + }; + { + name := "LackOfFundForMaxFee"; + item := + StructRecord + [ + ("fee", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "alloc::alloc::Global" + ]); + ("balance", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "alloc::alloc::Global" + ]) + ]; + discriminant := None; + }; + { + name := "OverflowPaymentInTransaction"; + item := StructTuple []; + discriminant := None; + }; + { + name := "NonceOverflowInTransaction"; + item := StructTuple []; + discriminant := None; + }; + { + name := "NonceTooHigh"; + item := StructRecord [ ("tx", Ty.path "u64"); ("state", Ty.path "u64") ]; + discriminant := None; + }; + { + name := "NonceTooLow"; + item := StructRecord [ ("tx", Ty.path "u64"); ("state", Ty.path "u64") ]; + discriminant := None; + }; + { + name := "CreateInitCodeSizeLimit"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidChainId"; + item := StructTuple []; + discriminant := None; + }; + { + name := "AccessListNotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "MaxFeePerBlobGasNotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "BlobVersionedHashesNotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "BlobGasPriceGreaterThanMax"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EmptyBlobs"; + item := StructTuple []; + discriminant := None; + }; + { + name := "BlobCreateTransaction"; + item := StructTuple []; + discriminant := None; + }; + { + name := "TooManyBlobs"; + item := StructRecord [ ("max", Ty.path "usize"); ("have", Ty.path "usize") ]; + discriminant := None; + }; + { + name := "BlobVersionNotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EofCrateShouldHaveToAddress"; + item := StructTuple []; + discriminant := None; + }; + { + name := "AuthorizationListNotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "AuthorizationListInvalidFields"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EmptyAuthorizationList"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidAuthorizationList"; + item := + StructTuple + [ Ty.path "revm_specification::eip7702::authorization_list::InvalidAuthorization" ]; + discriminant := None; + }; + { + name := "Eip2930NotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip1559NotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip4844NotSupported"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip7702NotSupported"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "PriorityFeeGreaterThanMaxFee" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "GasPriceLessThanBasefee" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CallerGasLimitMoreThanBlock" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CallGasCostMoreThanGasLimit" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "RejectCallerWithCode" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "LackOfFundForMaxFee" |); + M.read (| Value.String "fee" |); + M.read (| __self_0 |); + M.read (| Value.String "balance" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "OverflowPaymentInTransaction" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "NonceOverflowInTransaction" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "NonceTooHigh" |); + M.read (| Value.String "tx" |); + M.read (| __self_0 |); + M.read (| Value.String "state" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "NonceTooLow" |); + M.read (| Value.String "tx" |); + M.read (| __self_0 |); + M.read (| Value.String "state" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CreateInitCodeSizeLimit" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidChainId" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "InvalidChainId" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "AccessListNotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "MaxFeePerBlobGasNotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "BlobVersionedHashesNotSupported" |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "BlobGasPriceGreaterThanMax" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "EmptyBlobs" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "BlobCreateTransaction" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "TooManyBlobs" |); + M.read (| Value.String "max" |); + M.read (| __self_0 |); + M.read (| Value.String "have" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "BlobVersionNotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "EofCrateShouldHaveToAddress" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "AuthorizationListNotSupported" |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "AuthorizationListInvalidFields" |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "EmptyAuthorizationList" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "InvalidAuthorizationList" |); + __self_0 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "Eip2930NotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "Eip1559NotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "Eip4844NotSupported" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "Eip7702NotSupported" |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee" + [ + ("fee", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("balance", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::InvalidTransaction::NonceTooHigh" + [ + ("tx", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("state", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::InvalidTransaction::NonceTooLow" + [ + ("tx", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("state", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "u64", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidChainId" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::InvalidChainId" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::result::InvalidTransaction::TooManyBlobs" + [ + ("max", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "usize", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("have", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "usize", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + [ + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path + "revm_specification::eip7702::authorization_list::InvalidAuthorization", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + [] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + |) in + M.alloc (| + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + [] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidTransaction" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidTransaction" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "usize" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "usize" ] ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "usize" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "usize" ] ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_specification::eip7702::authorization_list::InvalidAuthorization" + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.path + "revm_specification::eip7702::authorization_list::InvalidAuthorization" + ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool true |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidTransaction" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "u64", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "usize", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "usize", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path + "revm_specification::eip7702::authorization_list::InvalidAuthorization", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_revm_context_interface_transaction_TransactionError_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::TransactionError" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_revm_context_interface_transaction_TransactionError_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_convert_From_revm_specification_eip7702_authorization_list_InvalidAuthorization_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* + fn from(value: InvalidAuthorization) -> Self { + Self::InvalidAuthorizationList(value) + } + *) + Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ value ] => + ltac:(M.monadic + (let value := M.alloc (| value |) in + Value.StructTuple + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList" + [ M.read (| value |) ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::convert::From" + Self + (* Trait polymorphic types *) + [ (* T *) Ty.path "revm_specification::eip7702::authorization_list::InvalidAuthorization" ] + (* Instance *) [ ("from", InstanceField.Method from) ]. + End Impl_core_convert_From_revm_specification_eip7702_authorization_list_InvalidAuthorization_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_error_Error_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + Axiom Implements : + M.IsTraitInstance + "core::error::Error" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_error_Error_for_revm_context_interface_result_InvalidTransaction. + + Module Impl_core_fmt_Display_for_revm_context_interface_result_InvalidTransaction. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidTransaction". + + (* + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::PriorityFeeGreaterThanMaxFee => { + write!(f, "priority fee is greater than max fee") + } + Self::GasPriceLessThanBasefee => { + write!(f, "gas price is less than basefee") + } + Self::CallerGasLimitMoreThanBlock => { + write!(f, "caller gas limit exceeds the block gas limit") + } + Self::CallGasCostMoreThanGasLimit => { + write!(f, "call gas cost exceeds the gas limit") + } + Self::RejectCallerWithCode => { + write!(f, "reject transactions from senders with deployed code") + } + Self::LackOfFundForMaxFee { fee, balance } => { + write!(f, "lack of funds ({balance}) for max fee ({fee})") + } + Self::OverflowPaymentInTransaction => { + write!(f, "overflow payment in transaction") + } + Self::NonceOverflowInTransaction => { + write!(f, "nonce overflow in transaction") + } + Self::NonceTooHigh { tx, state } => { + write!(f, "nonce {tx} too high, expected {state}") + } + Self::NonceTooLow { tx, state } => { + write!(f, "nonce {tx} too low, expected {state}") + } + Self::CreateInitCodeSizeLimit => { + write!(f, "create initcode size limit") + } + Self::InvalidChainId => write!(f, "invalid chain ID"), + Self::AccessListNotSupported => write!(f, "access list not supported"), + Self::MaxFeePerBlobGasNotSupported => { + write!(f, "max fee per blob gas not supported") + } + Self::BlobVersionedHashesNotSupported => { + write!(f, "blob versioned hashes not supported") + } + Self::BlobGasPriceGreaterThanMax => { + write!(f, "blob gas price is greater than max fee per blob gas") + } + Self::EmptyBlobs => write!(f, "empty blobs"), + Self::BlobCreateTransaction => write!(f, "blob create transaction"), + Self::TooManyBlobs { max, have } => { + write!(f, "too many blobs, have {have}, max {max}") + } + Self::BlobVersionNotSupported => write!(f, "blob version not supported"), + Self::EofCrateShouldHaveToAddress => write!(f, "EOF crate should have `to` address"), + Self::AuthorizationListNotSupported => write!(f, "authorization list not supported"), + Self::AuthorizationListInvalidFields => { + write!(f, "authorization list tx has invalid fields") + } + Self::EmptyAuthorizationList => write!(f, "empty authorization list"), + Self::Eip2930NotSupported => write!(f, "Eip2930 is not supported"), + Self::Eip1559NotSupported => write!(f, "Eip1559 is not supported"), + Self::Eip4844NotSupported => write!(f, "Eip4844 is not supported"), + Self::Eip7702NotSupported => write!(f, "Eip7702 is not supported"), + Self::InvalidAuthorizationList(i) => fmt::Display::fmt(i, f), + } + } + *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::PriorityFeeGreaterThanMaxFee" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "priority fee is greater than max fee" |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::GasPriceLessThanBasefee" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "gas price is less than basefee" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallerGasLimitMoreThanBlock" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "caller gas limit exceeds the block gas limit" + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CallGasCostMoreThanGasLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "call gas cost exceeds the gas limit" |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::RejectCallerWithCode" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String + "reject transactions from senders with deployed code" + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "fee" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::LackOfFundForMaxFee", + "balance" + |) in + let fee := M.alloc (| γ1_0 |) in + let balance := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| Value.String "lack of funds (" |); + M.read (| Value.String ") for max fee (" |); + M.read (| Value.String ")" |) + ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ] + ] + |), + [ balance ] + |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "alloc::alloc::Global" + ] + ] + ] + |), + [ fee ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::OverflowPaymentInTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "overflow payment in transaction" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceOverflowInTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "nonce overflow in transaction" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooHigh", + "state" + |) in + let tx := M.alloc (| γ1_0 |) in + let state := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| Value.String "nonce " |); + M.read (| Value.String " too high, expected " |) + ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ] + |), + [ tx ] + |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ] + |), + [ state ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "tx" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::NonceTooLow", + "state" + |) in + let tx := M.alloc (| γ1_0 |) in + let state := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| Value.String "nonce " |); + M.read (| Value.String " too low, expected " |) + ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ] + |), + [ tx ] + |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ] + |), + [ state ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::CreateInitCodeSizeLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "create initcode size limit" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidChainId" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "invalid chain ID" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AccessListNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "access list not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::MaxFeePerBlobGasNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "max fee per blob gas not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionedHashesNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "blob versioned hashes not supported" |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobGasPriceGreaterThanMax" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String + "blob gas price is greater than max fee per blob gas" + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyBlobs" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ M.alloc (| Value.Array [ M.read (| Value.String "empty blobs" |) ] |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobCreateTransaction" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "blob create transaction" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "max" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context_interface::result::InvalidTransaction::TooManyBlobs", + "have" + |) in + let max := M.alloc (| γ1_0 |) in + let have := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| Value.String "too many blobs, have " |); + M.read (| Value.String ", max " |) + ] + |); + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "usize" ] ] + |), + [ have ] + |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "new_display", + [ Ty.apply (Ty.path "&") [] [ Ty.path "usize" ] ] + |), + [ max ] + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::BlobVersionNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "blob version not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EofCrateShouldHaveToAddress" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "EOF crate should have `to` address" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListNotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "authorization list not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::AuthorizationListInvalidFields" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "authorization list tx has invalid fields" + |) + ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::EmptyAuthorizationList" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "empty authorization list" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip2930NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "Eip2930 is not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip1559NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "Eip1559 is not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip4844NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "Eip4844 is not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidTransaction::Eip7702NotSupported" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "Eip7702 is not supported" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::InvalidTransaction::InvalidAuthorizationList", + 0 + |) in + let i := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::fmt::Display", + Ty.path + "revm_specification::eip7702::authorization_list::InvalidAuthorization", + [], + "fmt", + [] + |), + [ M.read (| i |); M.read (| f |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Display" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Display_for_revm_context_interface_result_InvalidTransaction. + + (* + Enum InvalidHeader + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "PrevrandaoNotSet"; + item := StructTuple []; + discriminant := None; + }; + { + name := "ExcessBlobGasNotSet"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidHeader::PrevrandaoNotSet" + |) in + M.alloc (| M.read (| Value.String "PrevrandaoNotSet" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidHeader::ExcessBlobGasNotSet" + |) in + M.alloc (| M.read (| Value.String "ExcessBlobGasNotSet" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_marker_Copy_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| M.read (| self |) |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidHeader" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidHeader" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::InvalidHeader" ] + |), + [ M.read (| self |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_error_Error_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + Axiom Implements : + M.IsTraitInstance + "core::error::Error" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_error_Error_for_revm_context_interface_result_InvalidHeader. + + Module Impl_core_fmt_Display_for_revm_context_interface_result_InvalidHeader. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::InvalidHeader". + + (* + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::PrevrandaoNotSet => write!(f, "`prevrandao` not set"), + Self::ExcessBlobGasNotSet => write!(f, "`excess_blob_gas` not set"), + } + } + *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidHeader::PrevrandaoNotSet" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array [ M.read (| Value.String "`prevrandao` not set" |) ] + |) + ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::InvalidHeader::ExcessBlobGasNotSet" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_fmt", + [] + |), + [ + M.read (| f |); + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "`excess_blob_gas` not set" |) ] + |) + ] + |) + ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Display" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Display_for_revm_context_interface_result_InvalidHeader. + + (* + Enum SuccessReason + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Stop"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Return"; + item := StructTuple []; + discriminant := None; + }; + { + name := "SelfDestruct"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EofReturnContract"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::SuccessReason::Stop" + |) in + M.alloc (| M.read (| Value.String "Stop" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::SuccessReason::Return" + |) in + M.alloc (| M.read (| Value.String "Return" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::SuccessReason::SelfDestruct" + |) in + M.alloc (| M.read (| Value.String "SelfDestruct" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::SuccessReason::EofReturnContract" + |) in + M.alloc (| M.read (| Value.String "EofReturnContract" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| M.read (| self |) |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_marker_Copy_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::SuccessReason" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::SuccessReason" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_SuccessReason. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_SuccessReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::SuccessReason". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::SuccessReason" ] + |), + [ M.read (| self |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_SuccessReason. + + (* + Enum HaltReason + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "OutOfGas"; + item := StructTuple [ Ty.path "revm_context_interface::result::OutOfGasError" ]; + discriminant := None; + }; + { + name := "OpcodeNotFound"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidFEOpcode"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidJump"; + item := StructTuple []; + discriminant := None; + }; + { + name := "NotActivated"; + item := StructTuple []; + discriminant := None; + }; + { + name := "StackUnderflow"; + item := StructTuple []; + discriminant := None; + }; + { + name := "StackOverflow"; + item := StructTuple []; + discriminant := None; + }; + { + name := "OutOfOffset"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CreateCollision"; + item := StructTuple []; + discriminant := None; + }; + { + name := "PrecompileError"; + item := StructTuple []; + discriminant := None; + }; + { + name := "NonceOverflow"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CreateContractSizeLimit"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CreateContractStartingWithEF"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CreateInitCodeSizeLimit"; + item := StructTuple []; + discriminant := None; + }; + { + name := "OverflowPayment"; + item := StructTuple []; + discriminant := None; + }; + { + name := "StateChangeDuringStaticCall"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CallNotAllowedInsideStatic"; + item := StructTuple []; + discriminant := None; + }; + { + name := "OutOfFunds"; + item := StructTuple []; + discriminant := None; + }; + { + name := "CallTooDeep"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EofAuxDataOverflow"; + item := StructTuple []; + discriminant := None; + }; + { + name := "EofAuxDataTooSmall"; + item := StructTuple []; + discriminant := None; + }; + { + name := "SubRoutineStackOverflow"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidEXTCALLTarget"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::HaltReason::OutOfGas", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_tuple_field1_finish", + [] + |), + [ M.read (| f |); M.read (| Value.String "OutOfGas" |); __self_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::OpcodeNotFound" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "OpcodeNotFound" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::InvalidFEOpcode" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "InvalidFEOpcode" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::InvalidJump" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "InvalidJump" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::NotActivated" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "NotActivated" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::StackUnderflow" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "StackUnderflow" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::StackOverflow" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "StackOverflow" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::OutOfOffset" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "OutOfOffset" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CreateCollision" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CreateCollision" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::PrecompileError" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "PrecompileError" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::NonceOverflow" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "NonceOverflow" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CreateContractSizeLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CreateContractSizeLimit" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CreateContractStartingWithEF" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CreateContractStartingWithEF" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CreateInitCodeSizeLimit" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CreateInitCodeSizeLimit" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::OverflowPayment" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "OverflowPayment" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::StateChangeDuringStaticCall" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "StateChangeDuringStaticCall" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CallNotAllowedInsideStatic" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CallNotAllowedInsideStatic" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::OutOfFunds" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "OutOfFunds" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::CallTooDeep" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "CallTooDeep" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::EofAuxDataOverflow" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "EofAuxDataOverflow" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::EofAuxDataTooSmall" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "EofAuxDataTooSmall" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::SubRoutineStackOverflow" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "SubRoutineStackOverflow" |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::HaltReason::InvalidEXTCALLTarget" + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "write_str", + [] + |), + [ M.read (| f |); M.read (| Value.String "InvalidEXTCALLTarget" |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_HaltReason. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.read (| self |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_HaltReason. + + Module Impl_core_marker_Copy_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_result_HaltReason. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_HaltReason. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::HaltReason" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::HaltReason" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_0, + "revm_context_interface::result::HaltReason::OutOfGas", + 0 + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ0_1, + "revm_context_interface::result::HaltReason::OutOfGas", + 0 + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::OutOfGasError" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "revm_context_interface::result::OutOfGasError" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool true |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_HaltReason. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_HaltReason. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_HaltReason. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::HaltReason". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::HaltReason" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "revm_context_interface::result::HaltReason::OutOfGas", + 0 + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "revm_context_interface::result::OutOfGasError", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_HaltReason. + + (* + Enum OutOfGasError + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Basic"; + item := StructTuple []; + discriminant := None; + }; + { + name := "MemoryLimit"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Memory"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Precompile"; + item := StructTuple []; + discriminant := None; + }; + { + name := "InvalidOperand"; + item := StructTuple []; + discriminant := None; + }; + { + name := "ReentrancySentry"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::Basic" + |) in + M.alloc (| M.read (| Value.String "Basic" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::MemoryLimit" + |) in + M.alloc (| M.read (| Value.String "MemoryLimit" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::Memory" + |) in + M.alloc (| M.read (| Value.String "Memory" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::Precompile" + |) in + M.alloc (| M.read (| Value.String "Precompile" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::InvalidOperand" + |) in + M.alloc (| M.read (| Value.String "InvalidOperand" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::result::OutOfGasError::ReentrancySentry" + |) in + M.alloc (| M.read (| Value.String "ReentrancySentry" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_marker_Copy_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_clone_Clone_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| M.read (| self |) |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::OutOfGasError" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::OutOfGasError" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_cmp_Eq_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_result_OutOfGasError. + + Module Impl_core_hash_Hash_for_revm_context_interface_result_OutOfGasError. + Definition Self : Ty.t := Ty.path "revm_context_interface::result::OutOfGasError". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context_interface::result::OutOfGasError" ] + |), + [ M.read (| self |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_result_OutOfGasError. +End result. diff --git a/CoqOfRust/revm/translations/context/interface/transaction.json b/CoqOfRust/revm/translations/context/interface/transaction.json new file mode 100644 index 000000000..dec8b3ad0 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction.json @@ -0,0 +1,16031 @@ +[ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Trait": { + "name": "TransactionError", + "path": [ + "revm_context_interface", + "transaction", + "TransactionError" + ], + "const_params": [], + "ty_params": [], + "body": [] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Trait": { + "name": "Transaction", + "path": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "TransactionError", + { + "Type": [] + } + ], + [ + "TransactionType", + { + "Type": [] + } + ], + [ + "AccessList", + { + "Type": [] + } + ], + [ + "Legacy", + { + "Type": [] + } + ], + [ + "Eip2930", + { + "Type": [] + } + ], + [ + "Eip1559", + { + "Type": [] + } + ], + [ + "Eip4844", + { + "Type": [] + } + ], + [ + "Eip7702", + { + "Type": [] + } + ], + [ + "tx_type", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": "Associated" + } + } + } + } + ], + [ + "legacy", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: legacy tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "eip2930", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Eip2930 tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "eip1559", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Eip1559 tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "eip4844", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Eip4844 tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "eip7702", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Eip7702 tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "common_fields", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields", + "Trait" + ] + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Custom tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "max_fee", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Custom tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "effective_gas_price", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ], + [ + "base_fee", + { + "Path": { + "path": [ + "u128" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "base_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "tx_type", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Match": { + "scrutinee": { + "LocalVar": "tx_type" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Custom tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "max_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "max_priority_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "cmp", + "min" + ], + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "max_fee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "func": "saturating_add", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "max_priority_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ], + [ + "kind", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "tx_type", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "tx_type" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "alloy_primitives", + "common", + "TxKind", + "Call" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "alloy_primitives", + "common", + "TxKind", + "Call" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Custom tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "access_list", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "tx_type", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": "Associated", + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "tx_type" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "not implemented: Custom tx not supported" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "none", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "trait_ty_params": [], + "items": [ + { + "name": "TransactionError", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "TransactionType", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx_type", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "common_fields", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields", + "Trait" + ] + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "common_fields", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "effective_gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "base_fee", + { + "Path": { + "path": [ + "u128" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "base_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "effective_gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "trait_ty_params": [], + "items": [ + { + "name": "TransactionError", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "TransactionType", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx_type", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "common_fields", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields", + "Trait" + ] + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "common_fields", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "effective_gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "base_fee", + { + "Path": { + "path": [ + "u128" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "base_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "effective_gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "trait_ty_params": [], + "items": [ + { + "name": "TransactionError", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "TransactionType", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx_type", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "common_fields", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields", + "Trait" + ] + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "common_fields", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "effective_gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "base_fee", + { + "Path": { + "path": [ + "u128" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "base_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "effective_gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "trait_ty_params": [], + "items": [ + { + "name": "TransactionError", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "TransactionType", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx_type", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx_type", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "legacy", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "legacy", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip2930", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip2930", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip1559", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip1559", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip4844", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip4844", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip7702", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "eip7702", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "common_fields", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields", + "Trait" + ] + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "common_fields", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "effective_gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "base_fee", + { + "Path": { + "path": [ + "u128" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "base_fee", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "effective_gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "base_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Trait": { + "name": "TransactionGetter", + "path": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "Transaction", + { + "Type": [] + } + ], + [ + "tx", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Transaction", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "tx", + "snippet": [ + "#[auto_impl(&, &mut, Box, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionGetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "Trait": { + "name": "TransactionSetter", + "path": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "set_tx", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + "Associated" + ], + "ret": { + "Path": { + "path": [ + "unit" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_tx", + "snippet": [ + " fn set_tx(&mut self, block: ::Transaction) {", + " (**self).set_tx(block)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "block", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "set_tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "trait_ty_params": [], + "items": [ + { + "name": "set_tx", + "snippet": [ + " fn set_tx(&mut self, block: ::Transaction) {", + " (**self).set_tx(block)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "block", + "Associated", + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "block", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "TransactionSetter" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "set_tx", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "block" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction.v b/CoqOfRust/revm/translations/context/interface/transaction.v new file mode 100644 index 000000000..79ca806cf --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction.v @@ -0,0 +1,3101 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + (* Trait *) + (* Empty module 'TransactionError' *) + + (* Trait *) + Module Transaction. + Definition legacy (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Arguments", "new_v1", [] |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "not implemented: legacy tx not supported" |) ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_legacy : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "legacy" legacy. + Definition eip2930 (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Arguments", "new_v1", [] |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "not implemented: Eip2930 tx not supported" |) ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_eip2930 : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "eip2930" eip2930. + Definition eip1559 (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Arguments", "new_v1", [] |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "not implemented: Eip1559 tx not supported" |) ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_eip1559 : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "eip1559" eip1559. + Definition eip4844 (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Arguments", "new_v1", [] |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "not implemented: Eip4844 tx not supported" |) ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_eip4844 : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "eip4844" eip4844. + Definition eip7702 (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Arguments", "new_v1", [] |), + [ + M.alloc (| + Value.Array + [ M.read (| Value.String "not implemented: Eip7702 tx not supported" |) ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_eip7702 : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "eip7702" eip7702. + Definition common_fields + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "tx_type", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "legacy", + [] + |), + [ M.read (| self |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip2930", + [] + |), + [ M.read (| self |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "not implemented: Custom tx not supported" + |) + ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_common_fields : + M.IsProvidedMethod + "revm_context_interface::transaction::Transaction" + "common_fields" + common_fields. + Definition max_fee (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "tx_type", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + Ty.associated, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "legacy", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + Ty.associated, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip2930", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "not implemented: Custom tx not supported" + |) + ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_max_fee : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "max_fee" max_fee. + Definition effective_gas_price + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self; base_fee ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let base_fee := M.alloc (| base_fee |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ tx_type := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "tx_type", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + M.match_operator (| + M.match_operator (| + tx_type, + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + Ty.associated, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "legacy", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + Ty.associated, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip2930", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| + Value.Tuple + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + ] + |); + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_priority_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| + Value.Tuple + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + ] + |); + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_priority_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| + Value.Tuple + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + ] + |); + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "max_priority_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String + "not implemented: Custom tx not supported" + |) + ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |) + |))) + ] + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let max_fee := M.copy (| γ0_0 |) in + let max_priority_fee := M.copy (| γ0_1 |) in + M.alloc (| + M.call_closure (| + M.get_function (| "core::cmp::min", [ Ty.path "u128" ] |), + [ + M.read (| max_fee |); + M.call_closure (| + M.get_associated_function (| + Ty.path "u128", + "saturating_add", + [] + |), + [ M.read (| base_fee |); M.read (| max_priority_fee |) ] + |) + ] + |) + |))) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_effective_gas_price : + M.IsProvidedMethod + "revm_context_interface::transaction::Transaction" + "effective_gas_price" + effective_gas_price. + Definition kind (Self : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ tx_type := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "tx_type", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + M.match_operator (| + tx_type, + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + Ty.associated, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "legacy", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + Ty.associated, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip2930", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559Tx", + Ty.associated, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| + Value.StructTuple + "alloy_primitives::common::TxKind::Call" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + Ty.associated, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| + Value.StructTuple + "alloy_primitives::common::TxKind::Call" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + Ty.associated, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "not implemented: Custom tx not supported" + |) + ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_kind : + M.IsProvidedMethod "revm_context_interface::transaction::Transaction" "kind" kind. + Definition access_list + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ tx_type := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.associated, + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "into", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "tx_type", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + M.match_operator (| + tx_type, + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| Value.StructTuple "core::option::Option::None" [] |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + Ty.associated, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip2930", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip1559", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip4844", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + Ty.associated, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + Self, + [], + "eip7702", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_v1", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "not implemented: Custom tx not supported" + |) + ] + |); + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::rt::Argument", + "none", + [] + |), + [] + |) + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_access_list : + M.IsProvidedMethod + "revm_context_interface::transaction::Transaction" + "access_list" + access_list. + End Transaction. + + Module underscore. + Module Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionError (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionType (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Legacy (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip2930 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip1559 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip4844 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip7702 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition tx_type (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "tx_type", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition legacy (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "legacy", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip2930 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip2930", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip1559 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip1559", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip4844 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip4844", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip7702 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip7702", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition common_fields + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "common_fields", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "max_fee", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition effective_gas_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; base_fee ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let base_fee := M.alloc (| base_fee |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "effective_gas_price", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| base_fee |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::Transaction" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("TransactionError", InstanceField.Ty (_TransactionError T)); + ("TransactionType", InstanceField.Ty (_TransactionType T)); + ("AccessList", InstanceField.Ty (_AccessList T)); + ("Legacy", InstanceField.Ty (_Legacy T)); + ("Eip2930", InstanceField.Ty (_Eip2930 T)); + ("Eip1559", InstanceField.Ty (_Eip1559 T)); + ("Eip4844", InstanceField.Ty (_Eip4844 T)); + ("Eip7702", InstanceField.Ty (_Eip7702 T)); + ("tx_type", InstanceField.Method (tx_type T)); + ("legacy", InstanceField.Method (legacy T)); + ("eip2930", InstanceField.Method (eip2930 T)); + ("eip1559", InstanceField.Method (eip1559 T)); + ("eip4844", InstanceField.Method (eip4844 T)); + ("eip7702", InstanceField.Method (eip7702 T)); + ("common_fields", InstanceField.Method (common_fields T)); + ("max_fee", InstanceField.Method (max_fee T)); + ("effective_gas_price", InstanceField.Method (effective_gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionError (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionType (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Legacy (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip2930 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip1559 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip4844 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip7702 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition tx_type (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "tx_type", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition legacy (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "legacy", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip2930 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip2930", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip1559 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip1559", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip4844 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip4844", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip7702 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip7702", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition common_fields + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "common_fields", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "max_fee", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition effective_gas_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; base_fee ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let base_fee := M.alloc (| base_fee |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "effective_gas_price", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| base_fee |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::Transaction" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("TransactionError", InstanceField.Ty (_TransactionError T)); + ("TransactionType", InstanceField.Ty (_TransactionType T)); + ("AccessList", InstanceField.Ty (_AccessList T)); + ("Legacy", InstanceField.Ty (_Legacy T)); + ("Eip2930", InstanceField.Ty (_Eip2930 T)); + ("Eip1559", InstanceField.Ty (_Eip1559 T)); + ("Eip4844", InstanceField.Ty (_Eip4844 T)); + ("Eip7702", InstanceField.Ty (_Eip7702 T)); + ("tx_type", InstanceField.Method (tx_type T)); + ("legacy", InstanceField.Method (legacy T)); + ("eip2930", InstanceField.Method (eip2930 T)); + ("eip1559", InstanceField.Method (eip1559 T)); + ("eip4844", InstanceField.Method (eip4844 T)); + ("eip7702", InstanceField.Method (eip7702 T)); + ("common_fields", InstanceField.Method (common_fields T)); + ("max_fee", InstanceField.Method (max_fee T)); + ("effective_gas_price", InstanceField.Method (effective_gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionError (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionType (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Legacy (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip2930 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip1559 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip4844 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip7702 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition tx_type (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "tx_type", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition legacy (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "legacy", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip2930 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip2930", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip1559 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip1559", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip4844 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip4844", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip7702 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip7702", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition common_fields + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "common_fields", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "max_fee", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition effective_gas_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; base_fee ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let base_fee := M.alloc (| base_fee |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "effective_gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |); + M.read (| base_fee |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::Transaction" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("TransactionError", InstanceField.Ty (_TransactionError T)); + ("TransactionType", InstanceField.Ty (_TransactionType T)); + ("AccessList", InstanceField.Ty (_AccessList T)); + ("Legacy", InstanceField.Ty (_Legacy T)); + ("Eip2930", InstanceField.Ty (_Eip2930 T)); + ("Eip1559", InstanceField.Ty (_Eip1559 T)); + ("Eip4844", InstanceField.Ty (_Eip4844 T)); + ("Eip7702", InstanceField.Ty (_Eip7702 T)); + ("tx_type", InstanceField.Method (tx_type T)); + ("legacy", InstanceField.Method (legacy T)); + ("eip2930", InstanceField.Method (eip2930 T)); + ("eip1559", InstanceField.Method (eip1559 T)); + ("eip4844", InstanceField.Method (eip4844 T)); + ("eip7702", InstanceField.Method (eip7702 T)); + ("common_fields", InstanceField.Method (common_fields T)); + ("max_fee", InstanceField.Method (max_fee T)); + ("effective_gas_price", InstanceField.Method (effective_gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionError (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _TransactionType (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Legacy (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip2930 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip1559 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip4844 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _Eip7702 (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition tx_type (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "tx_type", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition legacy (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "legacy", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip2930 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip2930", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip1559 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip1559", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip4844 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip4844", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition eip7702 (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "eip7702", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition common_fields + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "common_fields", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "max_fee", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition effective_gas_price + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; base_fee ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let base_fee := M.alloc (| base_fee |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "effective_gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |); + M.read (| base_fee |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::Transaction", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::Transaction" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("TransactionError", InstanceField.Ty (_TransactionError T)); + ("TransactionType", InstanceField.Ty (_TransactionType T)); + ("AccessList", InstanceField.Ty (_AccessList T)); + ("Legacy", InstanceField.Ty (_Legacy T)); + ("Eip2930", InstanceField.Ty (_Eip2930 T)); + ("Eip1559", InstanceField.Ty (_Eip1559 T)); + ("Eip4844", InstanceField.Ty (_Eip4844 T)); + ("Eip7702", InstanceField.Ty (_Eip7702 T)); + ("tx_type", InstanceField.Method (tx_type T)); + ("legacy", InstanceField.Method (legacy T)); + ("eip2930", InstanceField.Method (eip2930 T)); + ("eip1559", InstanceField.Method (eip1559 T)); + ("eip4844", InstanceField.Method (eip4844 T)); + ("eip7702", InstanceField.Method (eip7702 T)); + ("common_fields", InstanceField.Method (common_fields T)); + ("max_fee", InstanceField.Method (max_fee T)); + ("effective_gas_price", InstanceField.Method (effective_gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_Transaction_where_revm_context_interface_transaction_Transaction_T_where_core_marker_Sized_T_for_alloc_rc_Rc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Transaction (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionGetter", + T, + [], + "tx", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Transaction", InstanceField.Ty (_Transaction T)); ("tx", InstanceField.Method (tx T)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Transaction (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionGetter", + T, + [], + "tx", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Transaction", InstanceField.Ty (_Transaction T)); ("tx", InstanceField.Method (tx T)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_ref_mut_T. + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Transaction (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionGetter", + T, + [], + "tx", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Transaction", InstanceField.Ty (_Transaction T)); ("tx", InstanceField.Method (tx T)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition _Transaction (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, &mut, Box, Arc)] *) + Definition tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionGetter", + T, + [], + "tx", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionGetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("Transaction", InstanceField.Ty (_Transaction T)); ("tx", InstanceField.Method (tx T)) + ]. + End Impl_revm_context_interface_transaction_TransactionGetter_where_revm_context_interface_transaction_TransactionGetter_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + End underscore. + + + + + (* Trait *) + (* Empty module 'TransactionGetter' *) + + + + + + (* Trait *) + (* Empty module 'TransactionSetter' *) + + Module Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_TransactionSetter_T_for_ref_mut_T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&mut") [] [ T ]. + + (* + fn set_tx(&mut self, block: ::Transaction) { + ( **self).set_tx(block) + } + *) + Definition set_tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionSetter", + T, + [], + "set_tx", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| block |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionSetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("set_tx", InstanceField.Method (set_tx T)) ]. + End Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_TransactionSetter_T_for_ref_mut_T. + + Module Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_TransactionSetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* + fn set_tx(&mut self, block: ::Transaction) { + ( **self).set_tx(block) + } + *) + Definition set_tx (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self; block ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let block := M.alloc (| block |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::TransactionSetter", + T, + [], + "set_tx", + [] + |), + [ M.read (| M.read (| self |) |); M.read (| block |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::TransactionSetter" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("set_tx", InstanceField.Method (set_tx T)) ]. + End Impl_revm_context_interface_transaction_TransactionSetter_where_revm_context_interface_transaction_TransactionSetter_T_for_alloc_boxed_Box_T_alloc_alloc_Global. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/access_list.json b/CoqOfRust/revm/translations/context/interface/transaction/access_list.json new file mode 100644 index 000000000..f7a8916d9 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/access_list.json @@ -0,0 +1,3476 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "access_list", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Trait": { + "name": "AccessListTrait", + "path": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "iter", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": "Associated" + } + } + } + } + ], + [ + "num_account_storages", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "storage_num", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "map", + "Map" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "usize" + ] + } + } + } + } + ] + } + }, + "trait_tys": [], + "method_name": "sum", + "generic_tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "map", + "generic_tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "usize" + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "i", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "count", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "i" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account_num", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "count", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account_num" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage_num" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "trait_ty_params": [], + "items": [ + { + "name": "iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "num_account_storages", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "num_account_storages", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "trait_ty_params": [], + "items": [ + { + "name": "iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "num_account_storages", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "num_account_storages", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "trait_ty_params": [], + "items": [ + { + "name": "iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "num_account_storages", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "num_account_storages", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "trait_ty_params": [], + "items": [ + { + "name": "iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "num_account_storages", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Path": { + "path": [ + "usize" + ] + } + }, + { + "Path": { + "path": [ + "usize" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "num_account_storages", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/access_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "access_list", + "AccessListTrait" + ], + "trait_ty_params": [], + "items": [ + { + "name": "iter", + "snippet": [ + " fn iter(&self) -> impl Iterator)> {", + " self.0.iter().map(|item| {", + " let slots = item.storage_keys.iter().copied();", + " (item.address, slots)", + " })", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessListItem" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "map", + "generic_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "copied", + "Copied" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessListItem" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "copied", + "Copied" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessListItem" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessListItem" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "alloy_eip2930::AccessList" + }, + { + "LocalVar": "0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessListItem" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "item", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "slots", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "copied", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "item" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "alloy_eip2930::AccessListItem" + }, + { + "InternalString": "storage_keys" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "item" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "alloy_eip2930::AccessListItem" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slots" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "num_account_storages", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/access_list.v b/CoqOfRust/revm/translations/context/interface/transaction/access_list.v new file mode 100644 index 000000000..e417dfc9c --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/access_list.v @@ -0,0 +1,663 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module access_list. + (* Trait *) + Module AccessListTrait. + Definition num_account_storages + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ storage_num := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::iter::adapters::map::Map") + [] + [ + Ty.associated; + Ty.function + [ + Ty.tuple + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.associated + ] + ] + ] + (Ty.path "usize") + ], + [], + "sum", + [ Ty.path "usize" ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.associated, + [], + "map", + [ + Ty.path "usize"; + Ty.function + [ + Ty.tuple + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.associated + ] + ] + ] + (Ty.path "usize") + ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + Self, + [], + "iter", + [] + |), + [ M.read (| self |) ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let i := M.copy (| γ |) in + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.associated, + [], + "count", + [] + |), + [ M.read (| M.SubPointer.get_tuple_field (| i, 1 |) |) + ] + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + ] + |) + |) in + let~ account_num := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.associated, + [], + "count", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + Self, + [], + "iter", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [ M.read (| account_num |); M.read (| storage_num |) ] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_num_account_storages : + M.IsProvidedMethod + "revm_context_interface::transaction::access_list::AccessListTrait" + "num_account_storages" + num_account_storages. + End AccessListTrait. + + Module underscore. + Module Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition iter (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "iter", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition num_account_storages + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "num_account_storages", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::access_list::AccessListTrait" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("iter", InstanceField.Method (iter T)); + ("num_account_storages", InstanceField.Method (num_account_storages T)) + ]. + End Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition iter (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "iter", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition num_account_storages + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "num_account_storages", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::access_list::AccessListTrait" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("iter", InstanceField.Method (iter T)); + ("num_account_storages", InstanceField.Method (num_account_storages T)) + ]. + End Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition iter (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition num_account_storages + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "num_account_storages", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::access_list::AccessListTrait" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("iter", InstanceField.Method (iter T)); + ("num_account_storages", InstanceField.Method (num_account_storages T)) + ]. + End Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition iter (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition num_account_storages + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::access_list::AccessListTrait", + T, + [], + "num_account_storages", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::access_list::AccessListTrait" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("iter", InstanceField.Method (iter T)); + ("num_account_storages", InstanceField.Method (num_account_storages T)) + ]. + End Impl_revm_context_interface_transaction_access_list_AccessListTrait_where_revm_context_interface_transaction_access_list_AccessListTrait_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + + Module Impl_revm_context_interface_transaction_access_list_AccessListTrait_for_alloy_eip2930_AccessList. + Definition Self : Ty.t := Ty.path "alloy_eip2930::AccessList". + + (* + fn iter(&self) -> impl Iterator)> { + self.0.iter().map(|item| { + let slots = item.storage_keys.iter().copied(); + (item.address, slots) + }) + } + *) + Definition iter (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::slice::iter::Iter") + [] + [ Ty.path "alloy_eip2930::AccessListItem" ], + [], + "map", + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "core::iter::adapters::copied::Copied") + [] + [ + Ty.apply + (Ty.path "core::slice::iter::Iter") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ] + ] + ]; + Ty.function + [ + Ty.tuple + [ Ty.apply (Ty.path "&") [] [ Ty.path "alloy_eip2930::AccessListItem" ] ] + ] + (Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "core::iter::adapters::copied::Copied") + [] + [ + Ty.apply + (Ty.path "core::slice::iter::Iter") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ] + ] + ]) + ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "slice") [] [ Ty.path "alloy_eip2930::AccessListItem" ], + "iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ Ty.path "alloy_eip2930::AccessListItem"; Ty.path "alloc::alloc::Global" + ], + [], + "deref", + [] + |), + [ + M.SubPointer.get_struct_tuple_field (| + M.read (| self |), + "alloy_eip2930::AccessList", + 0 + |) + ] + |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let item := M.copy (| γ |) in + M.read (| + let~ slots := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::slice::iter::Iter") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + [], + "copied", + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "deref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| item |), + "alloy_eip2930::AccessListItem", + "storage_keys" + |) + ] + |) + ] + |) + ] + |) + |) in + M.alloc (| + Value.Tuple + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| item |), + "alloy_eip2930::AccessListItem", + "address" + |) + |); + M.read (| slots |) + ] + |) + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::access_list::AccessListTrait" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("iter", InstanceField.Method iter) ]. + End Impl_revm_context_interface_transaction_access_list_AccessListTrait_for_alloy_eip2930_AccessList. + End access_list. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/common.json b/CoqOfRust/revm/translations/context/interface/transaction/common.json new file mode 100644 index 000000000..c18e1e41b --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/common.json @@ -0,0 +1,4244 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "common", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Trait": { + "name": "CommonTxFields", + "path": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "caller", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "gas_limit", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "value", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + } + } + } + } + ], + [ + "input", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "nonce", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "caller", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "caller", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "value", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "input", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "input", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "caller", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "caller", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "value", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "input", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "input", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "caller", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "caller", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "value", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "input", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "input", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/common.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "caller", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "caller", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_limit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "value", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "input", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "input", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/common.v b/CoqOfRust/revm/translations/context/interface/transaction/common.v new file mode 100644 index 000000000..30209e8d9 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/common.v @@ -0,0 +1,615 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module common. + (* Trait *) + (* Empty module 'CommonTxFields' *) + + Module underscore. + Module Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition caller (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "caller", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "gas_limit", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition value (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "value", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition input (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "input", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "nonce", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::common::CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("caller", InstanceField.Method (caller T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("value", InstanceField.Method (value T)); + ("input", InstanceField.Method (input T)); + ("nonce", InstanceField.Method (nonce T)) + ]. + End Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_ref__T. + Module Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition caller (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "caller", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "gas_limit", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition value (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "value", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition input (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "input", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "nonce", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::common::CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("caller", InstanceField.Method (caller T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("value", InstanceField.Method (value T)); + ("input", InstanceField.Method (input T)); + ("nonce", InstanceField.Method (nonce T)) + ]. + End Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition caller (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "caller", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "gas_limit", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition value (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "value", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition input (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "input", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "nonce", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::common::CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("caller", InstanceField.Method (caller T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("value", InstanceField.Method (value T)); + ("input", InstanceField.Method (input T)); + ("nonce", InstanceField.Method (nonce T)) + ]. + End Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition caller (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "caller", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_limit (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "gas_limit", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition value (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "value", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition input (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "input", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::common::CommonTxFields", + T, + [], + "nonce", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::common::CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("caller", InstanceField.Method (caller T)); + ("gas_limit", InstanceField.Method (gas_limit T)); + ("value", InstanceField.Method (value T)); + ("input", InstanceField.Method (input T)); + ("nonce", InstanceField.Method (nonce T)) + ]. + End Impl_revm_context_interface_transaction_common_CommonTxFields_where_revm_context_interface_transaction_common_CommonTxFields_T_where_core_marker_Sized_T_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + End common. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip1559.json b/CoqOfRust/revm/translations/context/interface/transaction/eip1559.json new file mode 100644 index 000000000..6ac802708 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip1559.json @@ -0,0 +1,4836 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "eip1559", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Trait": { + "name": "Eip1559Tx", + "path": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "kind", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Trait": { + "name": "Eip1559CommonTxFields", + "path": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "AccessList", + { + "Type": [] + } + ], + [ + "chain_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "max_fee_per_gas", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + } + } + ], + [ + "max_priority_fee_per_gas", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + } + } + ], + [ + "access_list", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_priority_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_priority_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_priority_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip1559.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_priority_fee_per_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_priority_fee_per_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip1559.v b/CoqOfRust/revm/translations/context/interface/transaction/eip1559.v new file mode 100644 index 000000000..3a983d97e --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip1559.v @@ -0,0 +1,741 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module eip1559. + (* Trait *) + (* Empty module 'Eip1559Tx' *) + + Module underscore. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559Tx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("kind", InstanceField.Method (kind T)) ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559Tx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("kind", InstanceField.Method (kind T)) ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559Tx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("kind", InstanceField.Method (kind T)) ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559Tx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) [ ("kind", InstanceField.Method (kind T)) ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_where_revm_context_interface_transaction_eip1559_Eip1559Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_fee_per_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_priority_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_priority_fee_per_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("max_fee_per_gas", InstanceField.Method (max_fee_per_gas T)); + ("max_priority_fee_per_gas", InstanceField.Method (max_priority_fee_per_gas T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_fee_per_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_priority_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_priority_fee_per_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("max_fee_per_gas", InstanceField.Method (max_fee_per_gas T)); + ("max_priority_fee_per_gas", InstanceField.Method (max_priority_fee_per_gas T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_priority_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_priority_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("max_fee_per_gas", InstanceField.Method (max_fee_per_gas T)); + ("max_priority_fee_per_gas", InstanceField.Method (max_priority_fee_per_gas T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_priority_fee_per_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "max_priority_fee_per_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("max_fee_per_gas", InstanceField.Method (max_fee_per_gas T)); + ("max_priority_fee_per_gas", InstanceField.Method (max_priority_fee_per_gas T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + + (* Trait *) + (* Empty module 'Eip1559CommonTxFields' *) + + + + + End eip1559. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip2930.json b/CoqOfRust/revm/translations/context/interface/transaction/eip2930.json new file mode 100644 index 000000000..c7b83cbda --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip2930.json @@ -0,0 +1,3560 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "eip2930", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Trait": { + "name": "Eip2930Tx", + "path": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "AccessList", + { + "Type": [] + } + ], + [ + "chain_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "gas_price", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + } + } + ], + [ + "kind", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "access_list", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip2930.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "access_list", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip2930.v b/CoqOfRust/revm/translations/context/interface/transaction/eip2930.v new file mode 100644 index 000000000..d595030c0 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip2930.v @@ -0,0 +1,542 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module eip2930. + (* Trait *) + (* Empty module 'Eip2930Tx' *) + + Module underscore. + Module Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "gas_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip2930::Eip2930Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "gas_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "access_list", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip2930::Eip2930Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip2930::Eip2930Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition _AccessList (T : Ty.t) : Ty.t := Ty.associated. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition access_list + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip2930::Eip2930Tx", + T, + [], + "access_list", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip2930::Eip2930Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty (_AccessList T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)); + ("kind", InstanceField.Method (kind T)); + ("access_list", InstanceField.Method (access_list T)) + ]. + End Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_where_revm_context_interface_transaction_eip2930_Eip2930Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + End eip2930. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip4844.json b/CoqOfRust/revm/translations/context/interface/transaction/eip4844.json new file mode 100644 index 000000000..282433c8a --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip4844.json @@ -0,0 +1,5018 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "eip4844", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Trait": { + "name": "Eip4844Tx", + "path": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "destination", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "blob_versioned_hashes", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "max_fee_per_blob_gas", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + } + } + ], + [ + "total_blob_gas", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "GAS_PER_BLOB" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "blob_versioned_hashes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Pure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ], + [ + "calc_max_data_fee", + { + "DefinitionWithDefault": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "blob_gas", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "from", + "generic_tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "total_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "max_blob_fee", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "from", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "Self" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "saturating_mul", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "max_blob_fee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_versioned_hashes", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_versioned_hashes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "total_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "total_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "calc_max_data_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "calc_max_data_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_versioned_hashes", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_versioned_hashes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "total_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "total_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "calc_max_data_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "calc_max_data_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_versioned_hashes", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_versioned_hashes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "total_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "total_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "calc_max_data_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "calc_max_data_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip4844.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_versioned_hashes", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "blob_versioned_hashes", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "max_fee_per_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "total_blob_gas", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "total_blob_gas", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "calc_max_data_fee", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "calc_max_data_fee", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip4844.v b/CoqOfRust/revm/translations/context/interface/transaction/eip4844.v new file mode 100644 index 000000000..3e9b1f9cc --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip4844.v @@ -0,0 +1,848 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module eip4844. + (* Trait *) + Module Eip4844Tx. + Definition total_blob_gas + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + BinOp.Wrap.mul (| + M.read (| M.get_constant (| "revm_specification::eip4844::GAS_PER_BLOB" |) |), + M.rust_cast + (M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "len", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + Self, + [], + "blob_versioned_hashes", + [] + |), + [ M.read (| self |) ] + |) + ] + |)) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_total_blob_gas : + M.IsProvidedMethod + "revm_context_interface::transaction::eip4844::Eip4844Tx" + "total_blob_gas" + total_blob_gas. + Definition calc_max_data_fee + (Self : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ blob_gas := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "from", + [ Ty.path "u64" ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + Self, + [], + "total_blob_gas", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + let~ max_blob_fee := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "from", + [ Ty.path "u128" ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + Self, + [], + "max_fee_per_blob_gas", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "saturating_mul", + [] + |), + [ M.read (| max_blob_fee |); M.read (| blob_gas |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom ProvidedMethod_calc_max_data_fee : + M.IsProvidedMethod + "revm_context_interface::transaction::eip4844::Eip4844Tx" + "calc_max_data_fee" + calc_max_data_fee. + End Eip4844Tx. + + Module underscore. + Module Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "destination", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition blob_versioned_hashes + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "blob_versioned_hashes", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "max_fee_per_blob_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition total_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "total_blob_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition calc_max_data_fee + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "calc_max_data_fee", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip4844::Eip4844Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("blob_versioned_hashes", InstanceField.Method (blob_versioned_hashes T)); + ("max_fee_per_blob_gas", InstanceField.Method (max_fee_per_blob_gas T)); + ("total_blob_gas", InstanceField.Method (total_blob_gas T)); + ("calc_max_data_fee", InstanceField.Method (calc_max_data_fee T)) + ]. + End Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "destination", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition blob_versioned_hashes + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "blob_versioned_hashes", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "max_fee_per_blob_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition total_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "total_blob_gas", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition calc_max_data_fee + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "calc_max_data_fee", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip4844::Eip4844Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("blob_versioned_hashes", InstanceField.Method (blob_versioned_hashes T)); + ("max_fee_per_blob_gas", InstanceField.Method (max_fee_per_blob_gas T)); + ("total_blob_gas", InstanceField.Method (total_blob_gas T)); + ("calc_max_data_fee", InstanceField.Method (calc_max_data_fee T)) + ]. + End Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition blob_versioned_hashes + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "blob_versioned_hashes", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "max_fee_per_blob_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition total_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "total_blob_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition calc_max_data_fee + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "calc_max_data_fee", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip4844::Eip4844Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("blob_versioned_hashes", InstanceField.Method (blob_versioned_hashes T)); + ("max_fee_per_blob_gas", InstanceField.Method (max_fee_per_blob_gas T)); + ("total_blob_gas", InstanceField.Method (total_blob_gas T)); + ("calc_max_data_fee", InstanceField.Method (calc_max_data_fee T)) + ]. + End Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition blob_versioned_hashes + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "blob_versioned_hashes", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition max_fee_per_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "max_fee_per_blob_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition total_blob_gas + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "total_blob_gas", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition calc_max_data_fee + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip4844::Eip4844Tx", + T, + [], + "calc_max_data_fee", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip4844::Eip4844Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("blob_versioned_hashes", InstanceField.Method (blob_versioned_hashes T)); + ("max_fee_per_blob_gas", InstanceField.Method (max_fee_per_blob_gas T)); + ("total_blob_gas", InstanceField.Method (total_blob_gas T)); + ("calc_max_data_fee", InstanceField.Method (calc_max_data_fee T)) + ]. + End Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_where_revm_context_interface_transaction_eip4844_Eip4844Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + End eip4844. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip7702.json b/CoqOfRust/revm/translations/context/interface/transaction/eip7702.json new file mode 100644 index 000000000..1643c4bb7 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip7702.json @@ -0,0 +1,6681 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "eip7702", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Trait": { + "name": "Eip7702Tx", + "path": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "destination", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "authorization_list_len", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "usize" + ] + } + } + } + } + } + } + ], + [ + "authorization_list_iter", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": "Associated" + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_len", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_len", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_len", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "destination", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_len", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_iter", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authorization_list_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Trait": { + "name": "Authorization", + "path": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "authority", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + } + } + } + ], + [ + "chain_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "nonce", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u64" + ] + } + } + } + } + } + } + ], + [ + "address", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "is_invalid", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "bool" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "trait_ty_params": [], + "items": [ + { + "name": "authority", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authority", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "address", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_invalid", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_invalid", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "trait_ty_params": [], + "items": [ + { + "name": "authority", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "authority", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "address", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_invalid", + "snippet": [ + "#[auto_impl(&, Arc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "is_invalid", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/eip7702.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Authorization" + ], + "trait_ty_params": [], + "items": [ + { + "name": "authority", + "snippet": [ + " fn authority(&self) -> Option
{", + " self.authority()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "authority", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + " fn chain_id(&self) -> u64 {", + " // TODO : `chain_id` is set as u64 in newest EIP-7702 spec", + " self.inner().chain_id().try_into().unwrap()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "from", + "FromUintError" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "TryInto" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + "method_name": "try_into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "Authorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "inner", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + " fn nonce(&self) -> u64 {", + " self.inner().nonce()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "Authorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "inner", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "address", + "snippet": [ + " fn address(&self) -> Address {", + " *self.inner().address()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "Authorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "inner", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "is_invalid", + "snippet": [ + " fn is_invalid(&self) -> bool {", + " use specification::{eip2::SECP256K1N_HALF, eip7702::Parity};", + "", + " // Check y_parity, Parity::Parity means that it was 0 or 1.", + " if !matches!(self.inner().signature().v(), Parity::Parity(_)) {", + " return true;", + " }", + "", + " // Check s-value", + " if self.inner().signature().s() > SECP256K1N_HALF {", + " return true;", + " }", + "", + " false", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "signature", + "sig", + "Signature" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "v", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "signature", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "inner", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "alloy_primitives::signature::parity::Parity::Parity" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Literal": { + "Bool": true + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialOrd" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "gt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "signature", + "sig", + "Signature" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "s", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "signature", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "inner", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "GetConst": [ + "revm_specification", + "eip2", + "SECP256K1N_HALF" + ] + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Literal": { + "Bool": true + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/eip7702.v b/CoqOfRust/revm/translations/context/interface/transaction/eip7702.v new file mode 100644 index 000000000..4da066215 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/eip7702.v @@ -0,0 +1,1151 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module eip7702. + (* Trait *) + (* Empty module 'Eip7702Tx' *) + + Module underscore. + Module Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "destination", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_len + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_len", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_iter + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_iter", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Eip7702Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("authorization_list_len", InstanceField.Method (authorization_list_len T)); + ("authorization_list_iter", InstanceField.Method (authorization_list_iter T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "destination", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_len + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_len", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_iter + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_iter", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Eip7702Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("authorization_list_len", InstanceField.Method (authorization_list_len T)); + ("authorization_list_iter", InstanceField.Method (authorization_list_iter T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_len + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_len", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_iter + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Eip7702Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("authorization_list_len", InstanceField.Method (authorization_list_len T)); + ("authorization_list_iter", InstanceField.Method (authorization_list_iter T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition destination + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "destination", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_len + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_len", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition authorization_list_iter + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Eip7702Tx", + T, + [], + "authorization_list_iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Eip7702Tx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method (destination T)); + ("authorization_list_len", InstanceField.Method (authorization_list_len T)); + ("authorization_list_iter", InstanceField.Method (authorization_list_iter T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_where_revm_context_interface_transaction_eip7702_Eip7702Tx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_eip1559_Eip1559Tx_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_eip7702_Authorization_where_revm_context_interface_transaction_eip7702_Authorization_T_where_core_marker_Sized_T_where_core_clone_Clone_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Arc)] *) + Definition authority (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "authority", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "nonce", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition address (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "address", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition is_invalid + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "is_invalid", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Authorization" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("authority", InstanceField.Method (authority T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("nonce", InstanceField.Method (nonce T)); + ("address", InstanceField.Method (address T)); + ("is_invalid", InstanceField.Method (is_invalid T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Authorization_where_revm_context_interface_transaction_eip7702_Authorization_T_where_core_marker_Sized_T_where_core_clone_Clone_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_eip7702_Authorization_where_revm_context_interface_transaction_eip7702_Authorization_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Arc)] *) + Definition authority (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "authority", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition nonce (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "nonce", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition address (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "address", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Arc)] *) + Definition is_invalid + (T : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::eip7702::Authorization", + T, + [], + "is_invalid", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Authorization" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("authority", InstanceField.Method (authority T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("nonce", InstanceField.Method (nonce T)); + ("address", InstanceField.Method (address T)); + ("is_invalid", InstanceField.Method (is_invalid T)) + ]. + End Impl_revm_context_interface_transaction_eip7702_Authorization_where_revm_context_interface_transaction_eip7702_Authorization_T_where_core_marker_Sized_T_where_core_clone_Clone_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + End underscore. + + + + + (* Trait *) + (* Empty module 'Authorization' *) + + + + Module Impl_revm_context_interface_transaction_eip7702_Authorization_for_revm_specification_eip7702_recovered_authorization_RecoveredAuthorization. + Definition Self : Ty.t := + Ty.path "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization". + + (* + fn authority(&self) -> Option
{ + self.authority() + } + *) + Definition authority (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "authority", + [] + |), + [ M.read (| self |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn chain_id(&self) -> u64 { + // TODO : `chain_id` is set as u64 in newest EIP-7702 spec + self.inner().chain_id().try_into().unwrap() + } + *) + Definition chain_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "u64"; + Ty.apply (Ty.path "ruint::from::FromUintError") [] [ Ty.path "u64" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::convert::TryInto", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ Ty.path "u64" ], + "try_into", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "alloy_eip7702::auth_list::Authorization", + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.path "alloy_eip7702::auth_list::SignedAuthorization", + [], + "deref", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "inner", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn nonce(&self) -> u64 { + self.inner().nonce() + } + *) + Definition nonce (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "alloy_eip7702::auth_list::Authorization", + "nonce", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.path "alloy_eip7702::auth_list::SignedAuthorization", + [], + "deref", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "inner", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn address(&self) -> Address { + *self.inner().address() + } + *) + Definition address (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.call_closure (| + M.get_associated_function (| + Ty.path "alloy_eip7702::auth_list::Authorization", + "address", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.path "alloy_eip7702::auth_list::SignedAuthorization", + [], + "deref", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "inner", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn is_invalid(&self) -> bool { + use specification::{eip2::SECP256K1N_HALF, eip7702::Parity}; + + // Check y_parity, Parity::Parity means that it was 0 or 1. + if !matches!(self.inner().signature().v(), Parity::Parity(_)) { + return true; + } + + // Check s-value + if self.inner().signature().s() > SECP256K1N_HALF { + return true; + } + + false + } + *) + Definition is_invalid (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + UnOp.not (| + M.read (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "alloy_primitives::signature::sig::Signature", + "v", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "alloy_eip7702::auth_list::SignedAuthorization", + "signature", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "inner", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "alloy_primitives::signature::parity::Parity::Parity", + 0 + |) in + M.alloc (| Value.Bool true |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |))) + ] + |) + |) + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| M.read (| M.return_ (| Value.Bool true |) |) |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialOrd", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "gt", + [] + |), + [ + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "alloy_primitives::signature::sig::Signature", + "s", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "alloy_eip7702::auth_list::SignedAuthorization", + "signature", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization", + "inner", + [] + |), + [ M.read (| self |) ] + |) + ] + |) + ] + |) + |); + M.get_constant (| + "revm_specification::eip2::SECP256K1N_HALF" + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| M.read (| M.return_ (| Value.Bool true |) |) |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| Value.Bool false |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Authorization" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("authority", InstanceField.Method authority); + ("chain_id", InstanceField.Method chain_id); + ("nonce", InstanceField.Method nonce); + ("address", InstanceField.Method address); + ("is_invalid", InstanceField.Method is_invalid) + ]. + End Impl_revm_context_interface_transaction_eip7702_Authorization_for_revm_specification_eip7702_recovered_authorization_RecoveredAuthorization. + End eip7702. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/legacy.json b/CoqOfRust/revm/translations/context/interface/transaction/legacy.json new file mode 100644 index 000000000..7c2502378 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/legacy.json @@ -0,0 +1,2834 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "legacy", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Trait": { + "name": "LegacyTx", + "path": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "const_params": [], + "ty_params": [], + "body": [ + [ + "kind", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + } + ], + [ + "chain_id", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + } + } + } + } + ], + [ + "gas_price", + { + "Definition": { + "const_params": [], + "ty_params": [], + "ty": { + "Function": { + "args": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "Self" + } + } + ] + } + } + ], + "ret": { + "Path": { + "path": [ + "u128" + ] + } + } + } + } + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "sync", + "Arc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "Module": { + "name": "underscore", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/legacy.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "T" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "core", + "marker", + "Sized" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "T" + } + } + }, + { + "bound": { + "name": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "ty_params": [] + }, + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "kind", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "chain_id", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + "#[auto_impl(&, Box, Arc, Rc)]" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "self_ty": { + "Var": { + "name": "T" + } + }, + "trait_tys": [], + "method_name": "gas_price", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "rc", + "Rc" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "T" + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/legacy.v b/CoqOfRust/revm/translations/context/interface/transaction/legacy.v new file mode 100644 index 000000000..9c236c343 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/legacy.v @@ -0,0 +1,397 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module legacy. + (* Trait *) + (* Empty module 'LegacyTx' *) + + Module underscore. + Module Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "&") [] [ T ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "gas_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::legacy::LegacyTx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("kind", InstanceField.Method (kind T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)) + ]. + End Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_ref__T_for_ref__T. + Module Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "kind", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "chain_id", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "gas_price", + [] + |), + [ M.read (| M.read (| self |) |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::legacy::LegacyTx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("kind", InstanceField.Method (kind T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)) + ]. + End Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_boxed_Box_T_alloc_alloc_Global_for_alloc_boxed_Box_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::sync::Arc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::sync::Arc") + [] + [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::legacy::LegacyTx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("kind", InstanceField.Method (kind T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)) + ]. + End Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_sync_Arc_T_alloc_alloc_Global_for_alloc_sync_Arc_T_alloc_alloc_Global. + Module Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + Definition Self (T : Ty.t) : Ty.t := + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ]. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition kind (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "kind", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition chain_id (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "chain_id", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* #[auto_impl(&, Box, Arc, Rc)] *) + Definition gas_price (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self T in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "revm_context_interface::transaction::legacy::LegacyTx", + T, + [], + "gas_price", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply (Ty.path "alloc::rc::Rc") [] [ T; Ty.path "alloc::alloc::Global" ], + [], + "deref", + [] + |), + [ M.read (| self |) ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (T : Ty.t), + M.IsTraitInstance + "revm_context_interface::transaction::legacy::LegacyTx" + (Self T) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("kind", InstanceField.Method (kind T)); + ("chain_id", InstanceField.Method (chain_id T)); + ("gas_price", InstanceField.Method (gas_price T)) + ]. + End Impl_revm_context_interface_transaction_legacy_LegacyTx_where_revm_context_interface_transaction_legacy_LegacyTx_T_where_core_marker_Sized_T_where_revm_context_interface_transaction_common_CommonTxFields_alloc_rc_Rc_T_alloc_alloc_Global_for_alloc_rc_Rc_T_alloc_alloc_Global. + End underscore. + + + + End legacy. +End transaction. diff --git a/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.json b/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.json new file mode 100644 index 000000000..4d245188d --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.json @@ -0,0 +1,1796 @@ +[ + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "Module": { + "name": "transaction", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "Module": { + "name": "transaction_type", + "body": [ + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TypeEnum": { + "name": "TransactionType", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Legacy", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip2930", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip1559", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip4844", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip7702", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Custom", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Legacy" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip2930" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip1559" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip4844" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip7702" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Custom" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/interface/src/transaction/transaction_type.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.v b/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.v new file mode 100644 index 000000000..d2eabee13 --- /dev/null +++ b/CoqOfRust/revm/translations/context/interface/transaction/transaction_type.v @@ -0,0 +1,303 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module transaction. + Module transaction_type. + (* + Enum TransactionType + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "Legacy"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip2930"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip1559"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip4844"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Eip7702"; + item := StructTuple []; + discriminant := None; + }; + { + name := "Custom"; + item := StructTuple []; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_clone_Clone_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| M.read (| self |) |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_marker_Copy_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + Axiom Implements : + M.IsTraitInstance + "core::marker::Copy" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_Copy_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_fmt_Debug_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.call_closure (| + M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |), + [ + M.read (| f |); + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + |) in + M.alloc (| M.read (| Value.String "Legacy" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip2930" + |) in + M.alloc (| M.read (| Value.String "Eip2930" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip1559" + |) in + M.alloc (| M.read (| Value.String "Eip1559" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip4844" + |) in + M.alloc (| M.read (| Value.String "Eip4844" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Eip7702" + |) in + M.alloc (| M.read (| Value.String "Eip7702" |) |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let _ := + M.is_struct_tuple (| + γ, + "revm_context_interface::transaction::transaction_type::TransactionType::Custom" + |) in + M.alloc (| M.read (| Value.String "Custom" |) |))) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_cmp_PartialEq_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_cmp_Eq_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.Tuple [])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_interface_transaction_transaction_type_TransactionType. + + Module Impl_core_hash_Hash_for_revm_context_interface_transaction_transaction_type_TransactionType. + Definition Self : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ] + |), + [ M.read (| self |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_interface_transaction_transaction_type_TransactionType. + End transaction_type. +End transaction. diff --git a/CoqOfRust/revm/translations/context/journaled_state.json b/CoqOfRust/revm/translations/context/journaled_state.json new file mode 100644 index 000000000..ecc6ec0d2 --- /dev/null +++ b/CoqOfRust/revm/translations/context/journaled_state.json @@ -0,0 +1,74432 @@ +[ + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "Module": { + "name": "journaled_state", + "body": [ + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TypeStructStruct": { + "name": "JournaledState", + "const_params": [], + "ty_params": [ + "DB" + ], + "fields": [ + [ + "database", + { + "Var": { + "name": "DB" + } + } + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "transient_storage", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "logs", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "depth", + { + "Path": { + "path": [ + "usize" + ] + } + } + ], + [ + "journal", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "spec", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "warm_preloaded_addresses", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "precompiles", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "fmt", + "Debug" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "names", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "database" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "state" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "transient_storage" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "logs" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "depth" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "journal" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "spec" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "warm_preloaded_addresses" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "precompiles" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "values", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_fields_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "JournaledState" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "names" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "values" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "clone", + "Clone" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ], + "fields": [ + [ + "database", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "transient_storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "logs", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "depth", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "journal", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "spec", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "warm_preloaded_addresses", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "precompiles", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "PartialEq" + ], + "ty_params": [ + [ + "Rhs", + "Default" + ] + ] + }, + "ty": { + "Var": { + "name": "DB" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [ + { + "Var": { + "name": "DB" + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [ + { + "bound": { + "name": [ + "core", + "cmp", + "Eq" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "predicates": [ + { + "bound": { + "name": [ + "revm_database_interface", + "Database" + ], + "ty_params": [] + }, + "ty": { + "Var": { + "name": "DB" + } + } + } + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "of_trait": [ + "revm_context_interface", + "journaled_state", + "Journal" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Database", + "snippet": [ + " type Database = DB;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Var": { + "name": "DB" + } + } + } + } + } + }, + { + "name": "FinalOutput", + "snippet": [ + " type FinalOutput = (EvmState, Vec);" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + } + } + } + }, + { + "name": "new", + "snippet": [ + " fn new(database: DB) -> JournaledState {", + " Self::new(SpecId::LATEST, database)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "database", + { + "Var": { + "name": "DB" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "body": { + "Let": { + "name": "database", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "database" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "database" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "db_ref", + "snippet": [ + " fn db_ref(&self) -> &Self::Database {", + " &self.database", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "db", + "snippet": [ + " fn db(&mut self) -> &mut Self::Database {", + " &mut self.database", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + " fn sload(", + " &mut self,", + " address: Address,", + " key: U256,", + " ) -> Result, ::Error> {", + " self.sload(address, key)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "sload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + " fn sstore(", + " &mut self,", + " address: Address,", + " key: U256,", + " value: U256,", + " ) -> Result, ::Error> {", + " self.sstore(address, key, value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "sstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + " fn tload(&mut self, address: Address, key: U256) -> U256 {", + " self.tload(address, key)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "tload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + " fn tstore(&mut self, address: Address, key: U256, value: U256) {", + " self.tstore(address, key, value)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "tstore", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + " fn log(&mut self, log: Log) {", + " self.log(log)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "log", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + " fn selfdestruct(", + " &mut self,", + " address: Address,", + " target: Address,", + " ) -> Result, DB::Error> {", + " self.selfdestruct(address, target)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "warm_account", + "snippet": [ + " fn warm_account(&mut self, address: Address) {", + " self.warm_preloaded_addresses.insert(address);", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "warm_precompiles", + "snippet": [ + " fn warm_precompiles(&mut self, address: HashSet
) {", + " self.precompiles = address;", + " self.warm_preloaded_addresses", + " .extend(self.precompiles.iter());", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "Extend" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "extend", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "precompile_addresses", + "snippet": [ + " fn precompile_addresses(&self) -> &HashSet
{", + " &self.precompiles", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "depth", + "snippet": [ + " fn depth(&self) -> usize {", + " self.depth", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "warm_account_and_storage", + "snippet": [ + " fn warm_account_and_storage(", + " &mut self,", + " address: Address,", + " storage_keys: impl IntoIterator,", + " ) -> Result<(), ::Error> {", + " self.initial_account_load(address, storage_keys)?;", + " Ok(())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "impl_IntoIterator_Item___U256_" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "storage_keys", + { + "Var": { + "name": "impl_IntoIterator_Item___U256_" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "storage_keys", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "storage_keys" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "initial_account_load", + "generic_tys": [ + { + "Var": { + "name": "impl_IntoIterator_Item___U256_" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage_keys" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "set_spec_id", + "snippet": [ + " fn set_spec_id(&mut self, spec_id: SpecId) {", + " self.spec = spec_id;", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "spec_id", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "spec_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "transfer", + "snippet": [ + " fn transfer(", + " &mut self,", + " from: &Address,", + " to: &Address,", + " balance: U256,", + " ) -> Result, DB::Error> {", + " // TODO : Handle instruction result", + " self.transfer(from, to, balance)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "from", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "to", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "transfer", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "touch_account", + "snippet": [ + " fn touch_account(&mut self, address: Address) {", + " self.touch(&address);", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "inc_account_nonce", + "snippet": [ + " fn inc_account_nonce(&mut self, address: Address) -> Result, DB::Error> {", + " Ok(self.inc_nonce(address))", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "inc_nonce", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account", + "snippet": [ + " fn load_account(&mut self, address: Address) -> Result, DB::Error> {", + " self.load_account(address)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account_code", + "snippet": [ + " fn load_account_code(", + " &mut self,", + " address: Address,", + " ) -> Result, DB::Error> {", + " self.load_code(address)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account_delegated", + "snippet": [ + " fn load_account_delegated(&mut self, address: Address) -> Result {", + " self.load_account_delegated(address)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint", + "snippet": [ + " fn checkpoint(&mut self) -> JournalCheckpoint {", + " self.checkpoint()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint_commit", + "snippet": [ + " fn checkpoint_commit(&mut self) {", + " self.checkpoint_commit()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint_commit", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint_revert", + "snippet": [ + " fn checkpoint_revert(&mut self, checkpoint: JournalCheckpoint) {", + " self.checkpoint_revert(checkpoint)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "checkpoint", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "checkpoint", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint_revert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "set_code_with_hash", + "snippet": [ + " fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) {", + " self.set_code_with_hash(address, code, hash);", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "code", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "hash", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "hash", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "set_code_with_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "clear", + "snippet": [ + " fn clear(&mut self) {", + " // Clears the JournaledState. Preserving only the spec.", + " self.state.clear();", + " self.transient_storage.clear();", + " self.logs.clear();", + " self.journal = vec![vec![]];", + " self.depth = 0;", + " self.warm_preloaded_addresses.clear();", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "into_vec", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "array" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "clear", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "create_account_checkpoint", + "snippet": [ + " fn create_account_checkpoint(", + " &mut self,", + " caller: Address,", + " address: Address,", + " balance: U256,", + " spec_id: SpecId,", + " ) -> Result {", + " // Ignore error.", + " self.create_account_checkpoint(caller, address, balance, spec_id)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "caller", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "spec_id", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "caller", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "caller" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "spec_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "create_account_checkpoint", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "caller" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "finalize", + "snippet": [ + " fn finalize(&mut self) -> Result::Error> {", + " let Self {", + " state,", + " transient_storage,", + " logs,", + " depth,", + " journal,", + " // kept, see [Self::new]", + " spec: _,", + " database: _,", + " warm_preloaded_addresses: _,", + " precompiles: _,", + " } = self;", + "", + " *transient_storage = TransientStorage::default();", + " *journal = vec![vec![]];", + " *depth = 0;", + " let state = mem::take(state);", + " let logs = mem::take(logs);", + "", + " Ok((state, logs))", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + "Associated", + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_4", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_5", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_6", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_7", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_8", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "precompiles" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "transient_storage", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "logs", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "depth", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "journal", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_4" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "into_vec", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "array" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "depth" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "mem", + "take" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "logs", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "mem", + "take" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "logs" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "set_code", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [ + "DB" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "items": [ + { + "name": "new", + "snippet": [ + " pub fn new(spec: SpecId, database: DB) -> JournaledState {", + " Self {", + " database,", + " state: HashMap::default(),", + " transient_storage: TransientStorage::default(),", + " logs: Vec::new(),", + " journal: vec![vec![]],", + " depth: 0,", + " spec,", + " warm_preloaded_addresses: HashSet::default(),", + " precompiles: HashSet::default(),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "spec", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "database", + { + "Var": { + "name": "DB" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "body": { + "Let": { + "name": "spec", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "database", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "database" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ], + "fields": [ + [ + "database", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "database" + } + ], + "kind": "Effectful" + } + } + ], + [ + "state", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "transient_storage", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "logs", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "journal", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "into_vec", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "array" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "depth", + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 0 + } + } + } + ], + [ + "spec", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + [ + "warm_preloaded_addresses", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "precompiles", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "state", + "snippet": [ + " pub fn state(&mut self) -> &mut EvmState {", + " &mut self.state", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "set_spec_id", + "snippet": [ + " pub fn set_spec_id(&mut self, spec: SpecId) {", + " self.spec = spec;", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "spec", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "spec", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "touch", + "snippet": [ + " pub fn touch(&mut self, address: &Address) {", + " if let Some(account) = self.state.get_mut(address) {", + " Self::touch_account(self.journal.last_mut().unwrap(), address, account);", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "touch_account", + "snippet": [ + " fn touch_account(journal: &mut Vec, address: &Address, account: &mut Account) {", + " if !account.is_touched() {", + " journal.push(JournalEntry::AccountTouched { address: *address });", + " account.mark_touch();", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "journal", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "account", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "journal", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "journal" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_touched", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountTouched" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_touch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "account", + "snippet": [ + " pub fn account(&self, address: Address) -> &Account {", + " self.state", + " .get(&address)", + " .expect(\"Account expected to be loaded\") // Always assume that acc is already loaded", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "expect", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Account expected to be loaded" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "set_code_with_hash", + "snippet": [ + " pub fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) {", + " let account = self.state.get_mut(&address).unwrap();", + " Self::touch_account(self.journal.last_mut().unwrap(), &address, account);", + "", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::CodeChange { address });", + "", + " account.info.code_hash = hash;", + " account.info.code = Some(code);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "code", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "hash", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "hash", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "LocalVar": "address" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "CodeChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "set_code", + "snippet": [ + " pub fn set_code(&mut self, address: Address, code: Bytecode) {", + " let hash = code.hash_slow();", + " self.set_code_with_hash(address, code, hash)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "code", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "hash", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "hash_slow", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "set_code_with_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "hash" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "inc_nonce", + "snippet": [ + " pub fn inc_nonce(&mut self, address: Address) -> Option {", + " let account = self.state.get_mut(&address).unwrap();", + " // Check if nonce is going to overflow.", + " if account.info.nonce == u64::MAX {", + " return None;", + " }", + " Self::touch_account(self.journal.last_mut().unwrap(), &address, account);", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::NonceChange { address });", + "", + " account.info.nonce += 1;", + "", + " Some(account.info.nonce)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "core", + "num", + "MAX" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "LocalVar": "address" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "NonceChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.add" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "transfer", + "snippet": [ + " pub fn transfer(", + " &mut self,", + " from: &Address,", + " to: &Address,", + " balance: U256,", + " ) -> Result, DB::Error> {", + " if balance.is_zero() {", + " self.load_account(*to)?;", + " let _ = self.load_account(*to)?;", + " let to_account = self.state.get_mut(to).unwrap();", + " Self::touch_account(self.journal.last_mut().unwrap(), to, to_account);", + " return Ok(None);", + " }", + " // load accounts", + " self.load_account(*from)?;", + " self.load_account(*to)?;", + "", + " // sub balance from", + " let from_account = &mut self.state.get_mut(from).unwrap();", + " Self::touch_account(self.journal.last_mut().unwrap(), from, from_account);", + " let from_balance = &mut from_account.info.balance;", + "", + " let Some(from_balance_incr) = from_balance.checked_sub(balance) else {", + " return Ok(Some(TransferError::OutOfFunds));", + " };", + " *from_balance = from_balance_incr;", + "", + " // add balance to", + " let to_account = &mut self.state.get_mut(to).unwrap();", + " Self::touch_account(self.journal.last_mut().unwrap(), to, to_account);", + " let to_balance = &mut to_account.info.balance;", + " let Some(to_balance_decr) = to_balance.checked_add(balance) else {", + " return Ok(Some(TransferError::OverflowPayment));", + " };", + " *to_balance = to_balance_decr;", + " // Overflow of U256 balance is not possible to happen on mainnet. We don't bother to return funds from from_acc.", + "", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::BalanceTransfer {", + " from: *from,", + " to: *to,", + " balance,", + " });", + "", + " Ok(None)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "from", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "to", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Match": { + "scrutinee": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "to_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ] + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "from_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from_balance", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "checked_sub", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from_balance_incr", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from_balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from_balance_incr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to_balance", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "checked_add", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to_balance_decr", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to_balance_decr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "BalanceTransfer" + ], + "fields": [ + [ + "from", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "to", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "balance", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "create_account_checkpoint", + "snippet": [ + " pub fn create_account_checkpoint(", + " &mut self,", + " caller: Address,", + " target_address: Address,", + " balance: U256,", + " spec_id: SpecId,", + " ) -> Result {", + " // Enter subroutine", + " let checkpoint = self.checkpoint();", + "", + " // Fetch balance of caller.", + " let caller_acc = self.state.get_mut(&caller).unwrap();", + " // Check if caller has enough balance to send to the created contract.", + " if caller_acc.info.balance < balance {", + " self.checkpoint_revert(checkpoint);", + " return Err(TransferError::OutOfFunds);", + " }", + "", + " // Newly created account is present, as we just loaded it.", + " let target_acc = self.state.get_mut(&target_address).unwrap();", + " let last_journal = self.journal.last_mut().unwrap();", + "", + " // New account can be created if:", + " // Bytecode is not empty.", + " // Nonce is not zero", + " // Account is not precompile.", + " if target_acc.info.code_hash != KECCAK_EMPTY || target_acc.info.nonce != 0 {", + " self.checkpoint_revert(checkpoint);", + " return Err(TransferError::CreateCollision);", + " }", + "", + " // set account status to created.", + " target_acc.mark_created();", + "", + " // this entry will revert set nonce.", + " last_journal.push(JournalEntry::AccountCreated {", + " address: target_address,", + " });", + " target_acc.info.code = None;", + " // EIP-161: State trie clearing (invariant-preserving alternative)", + " if spec_id.is_enabled_in(SPURIOUS_DRAGON) {", + " // nonce is going to be reset to zero in AccountCreated journal entry.", + " target_acc.info.nonce = 1;", + " }", + "", + " // touch account. This is important as for pre SpuriousDragon account could be", + " // saved even empty.", + " Self::touch_account(last_journal, &target_address, target_acc);", + "", + " // Add balance to created account, as we already have target here.", + " let Some(new_balance) = target_acc.info.balance.checked_add(balance) else {", + " self.checkpoint_revert(checkpoint);", + " return Err(TransferError::OverflowPayment);", + " };", + " target_acc.info.balance = new_balance;", + "", + " // safe to decrement for the caller as balance check is already done.", + " self.state.get_mut(&caller).unwrap().info.balance -= balance;", + "", + " // add journal entry of transferred balance", + " last_journal.push(JournalEntry::BalanceTransfer {", + " from: caller,", + " to: target_address,", + " balance,", + " });", + "", + " Ok(checkpoint)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "caller", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target_address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "spec_id", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "caller", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "caller" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target_address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target_address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "spec_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "checkpoint", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "caller_acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "caller" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialOrd" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "lt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "caller_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "balance" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint_revert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError", + "OutOfFunds" + ], + "fields": [] + } + } + ] + } + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "target_acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "target_address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "last_journal", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.or", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "ne", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + { + "GetConst": [ + "revm_primitives", + "KECCAK_EMPTY" + ] + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.ne" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "checkpoint_revert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Err" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_context_interface", + "journaled_state", + "TransferError", + "CreateCollision" + ], + "fields": [] + } + } + ] + } + } + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_created", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "last_journal" + } + ], + "kind": "Effectful" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountCreated" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_address" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_enabled_in", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SPURIOUS_DRAGON" + ], + "fields": [] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "last_journal" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "target_address" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "checked_add", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "new_balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "new_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "SubAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "sub_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "caller" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "last_journal" + } + ], + "kind": "Effectful" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "BalanceTransfer" + ], + "fields": [ + [ + "from", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "caller" + } + ], + "kind": "Effectful" + } + } + ], + [ + "to", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "balance", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "journal_revert", + "snippet": [ + " fn journal_revert(", + " state: &mut EvmState,", + " transient_storage: &mut TransientStorage,", + " journal_entries: Vec,", + " is_spurious_dragon_enabled: bool,", + " ) {", + " for entry in journal_entries.into_iter().rev() {", + " match entry {", + " JournalEntry::AccountWarmed { address } => {", + " state.get_mut(&address).unwrap().mark_cold();", + " }", + " JournalEntry::AccountTouched { address } => {", + " if is_spurious_dragon_enabled && address == PRECOMPILE3 {", + " continue;", + " }", + " // remove touched status", + " state.get_mut(&address).unwrap().unmark_touch();", + " }", + " JournalEntry::AccountDestroyed {", + " address,", + " target,", + " was_destroyed,", + " had_balance,", + " } => {", + " let account = state.get_mut(&address).unwrap();", + " // set previous state of selfdestructed flag, as there could be multiple", + " // selfdestructs in one transaction.", + " if was_destroyed {", + " // flag is still selfdestructed", + " account.mark_selfdestruct();", + " } else {", + " // flag that is not selfdestructed", + " account.unmark_selfdestruct();", + " }", + " account.info.balance += had_balance;", + "", + " if address != target {", + " let target = state.get_mut(&target).unwrap();", + " target.info.balance -= had_balance;", + " }", + " }", + " JournalEntry::BalanceTransfer { from, to, balance } => {", + " // we don't need to check overflow and underflow when adding and subtracting the balance.", + " let from = state.get_mut(&from).unwrap();", + " from.info.balance += balance;", + " let to = state.get_mut(&to).unwrap();", + " to.info.balance -= balance;", + " }", + " JournalEntry::NonceChange { address } => {", + " state.get_mut(&address).unwrap().info.nonce -= 1;", + " }", + " JournalEntry::AccountCreated { address } => {", + " let account = &mut state.get_mut(&address).unwrap();", + " account.unmark_created();", + " account", + " .storage", + " .values_mut()", + " .for_each(|slot| slot.mark_cold());", + " account.info.nonce = 0;", + " }", + " JournalEntry::StorageWarmed { address, key } => {", + " state", + " .get_mut(&address)", + " .unwrap()", + " .storage", + " .get_mut(&key)", + " .unwrap()", + " .mark_cold();", + " }", + " JournalEntry::StorageChanged {", + " address,", + " key,", + " had_value,", + " } => {", + " state", + " .get_mut(&address)", + " .unwrap()", + " .storage", + " .get_mut(&key)", + " .unwrap()", + " .present_value = had_value;", + " }", + " JournalEntry::TransientStorageChange {", + " address,", + " key,", + " had_value,", + " } => {", + " let tkey = (address, key);", + " if had_value.is_zero() {", + " // if previous value is zero, remove it", + " transient_storage.remove(&tkey);", + " } else {", + " // if not zero, reinsert old value to transient storage.", + " transient_storage.insert(tkey, had_value);", + " }", + " }", + " JournalEntry::CodeChange { address } => {", + " let acc = state.get_mut(&address).unwrap();", + " acc.info.code_hash = KECCAK_EMPTY;", + " acc.info.code = None;", + " }", + " }", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "transient_storage", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + null + ], + [ + "journal_entries", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "is_spurious_dragon_enabled", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "transient_storage", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "journal_entries", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "journal_entries" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_spurious_dragon_enabled", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "is_spurious_dragon_enabled" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Use": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "rev", + "Rev" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "rev", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "journal_entries" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "iter", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Loop": { + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "rev", + "Rev" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "next", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "iter" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::None" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "ControlFlow": "Break" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "entry" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_cold", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_spurious_dragon_enabled" + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "address" + }, + { + "GetConst": [ + "revm_primitives", + "constants", + "PRECOMPILE3" + ] + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "ControlFlow": "Continue" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "unmark_touch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "was_destroyed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "had_balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "LocalVar": "was_destroyed" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "unmark_selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "AddAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "add_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "had_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "ne", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "address" + }, + { + "LocalVar": "target" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "target" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "SubAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "sub_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "had_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "from", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "from" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "AddAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "add_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "from" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "to", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "to" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "SubAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "sub_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "to" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.sub" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "unmark_created", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "ValuesMut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "for_each", + "generic_tys": [ + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "values_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "slot", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_cold", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_cold", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "key" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "had_value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "key" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::EvmStorageSlot" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "had_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "had_value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "tkey", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "had_value" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "remove", + "generic_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "tkey" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "tkey" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "had_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_primitives", + "KECCAK_EMPTY" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint", + "snippet": [ + " pub fn checkpoint(&mut self) -> JournalCheckpoint {", + " let checkpoint = JournalCheckpoint {", + " log_i: self.logs.len(),", + " journal_i: self.journal.len(),", + " };", + " self.depth += 1;", + " self.journal.push(Default::default());", + " checkpoint", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "checkpoint", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ], + "fields": [ + [ + "log_i", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "journal_i", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.add" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "checkpoint" + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint_commit", + "snippet": [ + " pub fn checkpoint_commit(&mut self) {", + " self.depth -= 1;", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.sub" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "checkpoint_revert", + "snippet": [ + " pub fn checkpoint_revert(&mut self, checkpoint: JournalCheckpoint) {", + " let is_spurious_dragon_enabled = self.spec.is_enabled_in(SPURIOUS_DRAGON);", + " let state = &mut self.state;", + " let transient_storage = &mut self.transient_storage;", + " self.depth -= 1;", + " // iterate over last N journals sets and revert our global state", + " let leng = self.journal.len();", + " self.journal", + " .iter_mut()", + " .rev()", + " .take(leng - checkpoint.journal_i)", + " .for_each(|cs| {", + " Self::journal_revert(", + " state,", + " transient_storage,", + " mem::take(cs),", + " is_spurious_dragon_enabled,", + " )", + " });", + "", + " self.logs.truncate(checkpoint.log_i);", + " self.journal.truncate(checkpoint.journal_i);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "checkpoint", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "JournalCheckpoint" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "checkpoint", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "checkpoint" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "is_spurious_dragon_enabled", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_enabled_in", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SPURIOUS_DRAGON" + ], + "fields": [] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "transient_storage", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Let": { + "name": "β", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "depth" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "LocalVar": "β" + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.sub" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "β" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "body": { + "Let": { + "name": "leng", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "take", + "Take" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "rev", + "Rev" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "IterMut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "for_each", + "generic_tys": [ + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Tuple": { + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "rev", + "Rev" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "IterMut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "take", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "IterMut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "rev", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "iter_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.sub" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "leng" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "checkpoint" + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "journal_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "cs", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "journal_revert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "mem", + "take" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "cs" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_spurious_dragon_enabled" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "truncate", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "checkpoint" + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "log_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "truncate", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "checkpoint" + }, + { + "InternalString": "revm_context_interface::journaled_state::JournalCheckpoint" + }, + { + "InternalString": "journal_i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "selfdestruct", + "snippet": [ + " pub fn selfdestruct(", + " &mut self,", + " address: Address,", + " target: Address,", + " ) -> Result, DB::Error> {", + " let spec = self.spec;", + " let account_load = self.load_account(target)?;", + " let is_cold = account_load.is_cold;", + " let is_empty = account_load.state_clear_aware_is_empty(spec);", + "", + " if address != target {", + " // Both accounts are loaded before this point, `address` as we execute its contract.", + " // and `target` at the beginning of the function.", + " let acc_balance = self.state.get_mut(&address).unwrap().info.balance;", + "", + " let target_account = self.state.get_mut(&target).unwrap();", + " Self::touch_account(self.journal.last_mut().unwrap(), &target, target_account);", + " target_account.info.balance += acc_balance;", + " }", + "", + " let acc = self.state.get_mut(&address).unwrap();", + " let balance = acc.info.balance;", + " let previously_destroyed = acc.is_selfdestructed();", + " let is_cancun_enabled = self.spec.is_enabled_in(CANCUN);", + "", + " // EIP-6780 (Cancun hard-fork): selfdestruct only if contract is created in the same tx", + " let journal_entry = if acc.is_created() || !is_cancun_enabled {", + " acc.mark_selfdestruct();", + " acc.info.balance = U256::ZERO;", + " Some(JournalEntry::AccountDestroyed {", + " address,", + " target,", + " was_destroyed: previously_destroyed,", + " had_balance: balance,", + " })", + " } else if address != target {", + " acc.info.balance = U256::ZERO;", + " Some(JournalEntry::BalanceTransfer {", + " from: address,", + " to: target,", + " balance,", + " })", + " } else {", + " // State is not changed:", + " // * if we are after Cancun upgrade and", + " // * Selfdestruct account that is created in the same transaction and", + " // * Specify the target is same as selfdestructed account. The balance stays unchanged.", + " None", + " };", + "", + " if let Some(entry) = journal_entry {", + " self.journal.last_mut().unwrap().push(entry);", + " };", + "", + " Ok(StateLoad {", + " data: SelfDestructResult {", + " had_value: !balance.is_zero(),", + " target_exists: !is_empty,", + " previously_destroyed,", + " },", + " is_cold,", + " })", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "spec", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account_load", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "account_load" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_empty", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "state_clear_aware_is_empty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "account_load" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "ne", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "address" + }, + { + "LocalVar": "target" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "acc_balance", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "target_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "target" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "touch_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "LocalVar": "target" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "arith", + "AddAssign" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "add_assign", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target_account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc_balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "balance", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "previously_destroyed", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_selfdestructed", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cancun_enabled", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_enabled_in", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "CANCUN" + ], + "fields": [] + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "journal_entry", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.or", + "lhs": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_created", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cancun_enabled" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_selfdestruct", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountDestroyed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "target", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + [ + "was_destroyed", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ], + [ + "had_balance", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "ne", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "address" + }, + { + "LocalVar": "target" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "BalanceTransfer" + ], + "fields": [ + [ + "from", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "to", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "target" + } + ], + "kind": "Effectful" + } + } + ], + [ + "balance", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "LocalVar": "journal_entry" + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SelfDestructResult" + ], + "fields": [ + [ + "had_value", + { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "balance" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "target_exists", + { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "previously_destroyed", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "previously_destroyed" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "initial_account_load", + "snippet": [ + " pub fn initial_account_load(", + " &mut self,", + " address: Address,", + " storage_keys: impl IntoIterator,", + " ) -> Result<&mut Account, DB::Error> {", + " // load or get account.", + " let account = match self.state.entry(address) {", + " Entry::Occupied(entry) => entry.into_mut(),", + " Entry::Vacant(vac) => vac.insert(", + " self.database", + " .basic(address)?", + " .map(|i| i.into())", + " .unwrap_or(Account::new_not_existing()),", + " ),", + " };", + " // preload storages.", + " for storage_key in storage_keys.into_iter() {", + " if let Entry::Vacant(entry) = account.storage.entry(storage_key) {", + " let storage = self.database.storage(address, storage_key)?;", + " entry.insert(EvmStorageSlot::new(storage));", + " }", + " }", + " Ok(account)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "impl_IntoIterator_Item___U256_" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "storage_keys", + { + "Var": { + "name": "impl_IntoIterator_Item___U256_" + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "storage_keys", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "storage_keys" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "entry", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Occupied" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "OccupiedEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "into_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Vacant" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "vac", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "VacantEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "vac" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "map", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "basic", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "i", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "i" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_not_existing", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Use": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": { + "Var": { + "name": "impl_IntoIterator_Item___U256_" + } + }, + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage_keys" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "iter", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Loop": { + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": "Associated", + "trait_tys": [], + "method_name": "next", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "iter" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::None" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "ControlFlow": "Break" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "storage_key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "entry", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage_key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Vacant" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "storage", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "storage", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage_key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "VacantEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "storage" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account", + "snippet": [ + " pub fn load_account(&mut self, address: Address) -> Result, DB::Error> {", + " self.load_account_optional(address, false)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account_optional", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": false + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account_delegated", + "snippet": [ + " pub fn load_account_delegated(&mut self, address: Address) -> Result {", + " let spec = self.spec;", + " let account = self.load_code(address)?;", + " let is_empty = account.state_clear_aware_is_empty(spec);", + "", + " let mut account_load = AccountLoad {", + " is_empty,", + " load: Eip7702CodeLoad::new_not_delegated((), account.is_cold),", + " };", + " // load delegate code if account is EIP-7702", + " if let Some(Bytecode::Eip7702(code)) = &account.info.code {", + " let address = code.address();", + " let delegate_account = self.load_account(address)?;", + " account_load", + " .load", + " .set_delegate_load(delegate_account.is_cold);", + " }", + "", + " Ok(account_load)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "spec", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_code", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_empty", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "state_clear_aware_is_empty", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account_load", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ], + "fields": [ + [ + "is_empty", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_empty" + } + ], + "kind": "Effectful" + } + } + ], + [ + "load", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "new_not_delegated", + "generic_tys": [] + } + }, + "args": [ + { + "Tuple": { + "elements": [] + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "account" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ1_0" + }, + { + "InternalString": "revm_bytecode::bytecode::Bytecode::Eip7702" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "eip7702", + "Eip7702Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "address", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "delegate_account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "AccountLoad" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "Eip7702CodeLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + } + ] + } + }, + "func": "set_delegate_load", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "account_load" + }, + { + "InternalString": "revm_context_interface::journaled_state::AccountLoad" + }, + { + "InternalString": "load" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "delegate_account" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account_load" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_code", + "snippet": [ + " pub fn load_code(&mut self, address: Address) -> Result, DB::Error> {", + " self.load_account_optional(address, true)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "load_account_optional", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "load_account_optional", + "snippet": [ + " pub fn load_account_optional(", + " &mut self,", + " address: Address,", + " load_code: bool,", + " ) -> Result, DB::Error> {", + " let load = match self.state.entry(address) {", + " Entry::Occupied(entry) => {", + " let account = entry.into_mut();", + " let is_cold = account.mark_warm();", + " StateLoad {", + " data: account,", + " is_cold,", + " }", + " }", + " Entry::Vacant(vac) => {", + " let account = if let Some(account) = self.database.basic(address)? {", + " account.into()", + " } else {", + " Account::new_not_existing()", + " };", + "", + " // precompiles are warm loaded so we need to take that into account", + " let is_cold = !self.warm_preloaded_addresses.contains(&address);", + "", + " StateLoad {", + " data: vac.insert(account),", + " is_cold,", + " }", + " }", + " };", + " // journal loading of cold account.", + " if load.is_cold {", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::AccountWarmed { address });", + " }", + " if load_code {", + " let info = &mut load.data.info;", + " if info.code.is_none() {", + " if info.code_hash == KECCAK_EMPTY {", + " let empty = Bytecode::default();", + " info.code = Some(empty);", + " } else {", + " let code = self.database.code_by_hash(info.code_hash)?;", + " info.code = Some(code);", + " }", + " }", + " }", + "", + " Ok(load)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "load_code", + { + "Path": { + "path": [ + "bool" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "load_code", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "load_code" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "load", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "entry", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Occupied" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "entry", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "OccupiedEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "into_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "entry" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_warm", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Vacant" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "vac", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "basic", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "account", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "account_info", + "AccountInfo" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_not_existing", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "UnOp.not" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "set", + "HashSet" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "contains", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "warm_preloaded_addresses" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ], + "fields": [ + [ + "data", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "VacantEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "vac" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "is_cold", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "load" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountWarmed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "LocalVar": "load_code" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "info", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "load" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "info" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "is_none", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + }, + { + "GetConst": [ + "revm_primitives", + "KECCAK_EMPTY" + ] + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "empty", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "empty" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "code", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_bytecode", + "bytecode", + "Bytecode" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "code_by_hash", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code_hash" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "info" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::account_info::AccountInfo" + }, + { + "InternalString": "code" + } + ], + "kind": "Effectful" + } + }, + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "code" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "load" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sload", + "snippet": [ + " pub fn sload(&mut self, address: Address, key: U256) -> Result, DB::Error> {", + " // assume acc is warm", + " let account = self.state.get_mut(&address).unwrap();", + " // only if account is created in this tx we can assume that storage is empty.", + " let is_newly_created = account.is_created();", + " let (value, is_cold) = match account.storage.entry(key) {", + " Entry::Occupied(occ) => {", + " let slot = occ.into_mut();", + " let is_cold = slot.mark_warm();", + " (slot.present_value, is_cold)", + " }", + " Entry::Vacant(vac) => {", + " // if storage was cleared, we don't need to ping db.", + " let value = if is_newly_created {", + " U256::ZERO", + " } else {", + " self.database.storage(address, key)?", + " };", + "", + " vac.insert(EvmStorageSlot::new(value));", + "", + " (value, true)", + " }", + " };", + "", + " if is_cold {", + " // add it to journal as cold loaded.", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::StorageWarmed { address, key });", + " }", + "", + " Ok(StateLoad::new(value, is_cold))", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "account", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_newly_created", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "is_created", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "entry", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "account" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Occupied" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "occ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "slot", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "OccupiedEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "into_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "occ" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "mark_warm", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::EvmStorageSlot" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "hashbrown::map::Entry::Vacant" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "vac", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "LocalVar": "is_newly_created" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "ruint", + "ZERO" + ] + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "revm_database_interface", + "Database" + ], + "self_ty": { + "Var": { + "name": "DB" + } + }, + "trait_tys": [], + "method_name": "storage", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "database" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "VacantEntry" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "vac" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "is_cold", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "LocalVar": "is_cold" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "StorageWarmed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "sstore", + "snippet": [ + " pub fn sstore(", + " &mut self,", + " address: Address,", + " key: U256,", + " new: U256,", + " ) -> Result, DB::Error> {", + " // assume that acc exists and load the slot.", + " let present = self.sload(address, key)?;", + " let acc = self.state.get_mut(&address).unwrap();", + "", + " // if there is no original value in dirty return present value, that is our original.", + " let slot = acc.storage.get_mut(&key).unwrap();", + "", + " // new value is same as present, we don't need to do anything", + " if present.data == new {", + " return Ok(StateLoad::new(", + " SStoreResult {", + " original_value: slot.original_value(),", + " present_value: present.data,", + " new_value: new,", + " },", + " present.is_cold,", + " ));", + " }", + "", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::StorageChanged {", + " address,", + " key,", + " had_value: present.data,", + " });", + " // insert value into present state.", + " slot.present_value = new;", + " Ok(StateLoad::new(", + " SStoreResult {", + " original_value: slot.original_value(),", + " present_value: present.data,", + " new_value: new,", + " },", + " present.is_cold,", + " ))", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "new", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "new", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.catch_return" + }, + "args": [ + { + "Lambda": { + "args": [], + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "present", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "Try" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [], + "method_name": "branch", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + }, + "func": "sload", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Break" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "residual", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "try_trait", + "FromResidual" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "Associated" + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "convert", + "Infallible" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "Associated" + ] + } + } + ], + "method_name": "from_residual", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "residual" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::ops::control_flow::ControlFlow::Continue" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "val", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "val" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "acc", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "Account" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "state" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "address" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "slot", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get_mut", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "acc" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::Account" + }, + { + "InternalString": "storage" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "key" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "new" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Return": { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ], + "fields": [ + [ + "original_value", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "original_value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "present_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "new_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "StorageChanged" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + [ + "had_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.write" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_state::EvmStorageSlot" + }, + { + "InternalString": "present_value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "result", + "Result", + "Ok" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "journaled_state", + "StateLoad" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context_interface", + "host", + "SStoreResult" + ], + "fields": [ + [ + "original_value", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_state", + "EvmStorageSlot" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "original_value", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "slot" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "present_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + [ + "new_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "present" + }, + { + "InternalString": "revm_context_interface::journaled_state::StateLoad" + }, + { + "InternalString": "is_cold" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": false, + "is_internal": true + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tload", + "snippet": [ + " pub fn tload(&mut self, address: Address, key: U256) -> U256 {", + " self.transient_storage", + " .get(&(address, key))", + " .copied()", + " .unwrap_or_default()", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "copied", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "get", + "generic_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "tstore", + "snippet": [ + " pub fn tstore(&mut self, address: Address, key: U256, new: U256) {", + " let had_value = if new.is_zero() {", + " // if new values is zero, remove entry from transient storage.", + " // if previous values was some insert it inside journal.", + " // If it is none nothing should be inserted.", + " self.transient_storage.remove(&(address, key))", + " } else {", + " // insert values", + " let previous_value = self", + " .transient_storage", + " .insert((address, key), new)", + " .unwrap_or_default();", + "", + " // check if previous value is same", + " if previous_value != new {", + " // if it is different, insert previous values inside journal.", + " Some(previous_value)", + " } else {", + " None", + " }", + " };", + "", + " if let Some(had_value) = had_value {", + " // insert in journal only if value was changed.", + " self.journal", + " .last_mut()", + " .unwrap()", + " .push(JournalEntry::TransientStorageChange {", + " address,", + " key,", + " had_value,", + " });", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ], + [ + "new", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "address", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "key", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "new", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "had_value", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "is_zero", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "remove", + "generic_tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "previous_value", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "map", + "HashMap" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "foldhash", + "seed", + "fast", + "RandomState" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "hashbrown", + "raw", + "alloc", + "inner", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "insert", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "transient_storage" + } + ], + "kind": "Effectful" + } + }, + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ] + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "new" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Use": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "ne", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "previous_value" + }, + { + "LocalVar": "new" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Bool": true + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "previous_value" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "LocalVar": "had_value" + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "core::option::Option::Some" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "had_value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "func": "last_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "DerefMut" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref_mut", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "journal" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "TransientStorageChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "address" + } + ], + "kind": "Effectful" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "key" + } + ], + "kind": "Effectful" + } + } + ], + [ + "had_value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "had_value" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "log", + "snippet": [ + " pub fn log(&mut self, log: Log) {", + " self.logs.push(log);", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournaledState" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "DB" + } + } + ] + } + } + ] + } + }, + null + ], + [ + "log", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "unit" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "log", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "Log" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "log", + "LogData" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "push", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::journaled_state::JournaledState" + }, + { + "InternalString": "logs" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "log" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TypeEnum": { + "name": "JournalEntry", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "AccountWarmed", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "AccountDestroyed", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "target", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "was_destroyed", + { + "Path": { + "path": [ + "bool" + ] + } + } + ], + [ + "had_balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "AccountTouched", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "BalanceTransfer", + "item": { + "Struct": { + "fields": [ + [ + "from", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "to", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "balance", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "NonceChange", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "AccountCreated", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "StorageChanged", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "had_value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "StorageWarmed", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "TransientStorageChange", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "key", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "had_value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + }, + { + "name": "CodeChange", + "item": { + "Struct": { + "fields": [ + [ + "address", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccountWarmed" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field4_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccountDestroyed" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "target" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "was_destroyed" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "had_balance" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_3" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccountTouched" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field3_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BalanceTransfer" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "from" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "to" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "balance" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_2" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "NonceChange" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "AccountCreated" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field3_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StorageChanged" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "key" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "had_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_2" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "StorageWarmed" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "key" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_1" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field3_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "TransientStorageChange" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "key" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "had_value" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_2" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CodeChange" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "address" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountWarmed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountDestroyed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "target", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "was_destroyed", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "had_balance", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_3" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountTouched" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "BalanceTransfer" + ], + "fields": [ + [ + "from", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "to", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "balance", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "NonceChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "AccountCreated" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "StorageChanged" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "had_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "StorageWarmed" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "TransientStorageChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "key", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "had_value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructStruct": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry", + "CodeChange" + ], + "fields": [ + [ + "address", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "bool" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_2" + }, + { + "LocalVar": "__arg1_2" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_3" + }, + { + "LocalVar": "__arg1_3" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_2" + }, + { + "LocalVar": "__arg1_2" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_2" + }, + { + "LocalVar": "__arg1_2" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_1" + }, + { + "LocalVar": "__arg1_1" + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_2" + }, + { + "LocalVar": "__arg1_2" + } + ], + "kind": "Closure" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "unreachable" + ], + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/journaled_state.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "journaled_state", + "JournalEntry" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "target" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "was_destroyed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountDestroyed" + }, + { + "InternalString": "had_balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_3", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_3" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_3" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountTouched" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "from" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "to" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::BalanceTransfer" + }, + { + "InternalString": "balance" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::NonceChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::AccountCreated" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageChanged" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::StorageWarmed" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "key" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::TransientStorageChange" + }, + { + "InternalString": "had_value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_2", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_2" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_1" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_2" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_context::journaled_state::JournalEntry::CodeChange" + }, + { + "InternalString": "address" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/journaled_state.v b/CoqOfRust/revm/translations/context/journaled_state.v new file mode 100644 index 000000000..cccd7f48e --- /dev/null +++ b/CoqOfRust/revm/translations/context/journaled_state.v @@ -0,0 +1,14243 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module journaled_state. + (* StructRecord + { + name := "JournaledState"; + const_params := []; + ty_params := [ "DB" ]; + fields := + [ + ("database", DB); + ("state", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]); + ("transient_storage", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]); + ("logs", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ]); + ("depth", Ty.path "usize"); + ("journal", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ]); + ("spec", Ty.path "revm_specification::hardfork::SpecId"); + ("warm_preloaded_addresses", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]); + ("precompiles", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]) + ]; + } *) + + Module Impl_core_fmt_Debug_where_core_fmt_Debug_DB_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* Debug *) + Definition fmt (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ names := + M.alloc (| + M.alloc (| + Value.Array + [ + M.read (| Value.String "database" |); + M.read (| Value.String "state" |); + M.read (| Value.String "transient_storage" |); + M.read (| Value.String "logs" |); + M.read (| Value.String "depth" |); + M.read (| Value.String "journal" |); + M.read (| Value.String "spec" |); + M.read (| Value.String "warm_preloaded_addresses" |); + M.read (| Value.String "precompiles" |) + ] + |) + |) in + let~ values := + M.alloc (| + M.alloc (| + Value.Array + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |) + |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_fields_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "JournaledState" |); + M.read (| names |); + M.read (| values |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::fmt::Debug" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method (fmt DB)) ]. + End Impl_core_fmt_Debug_where_core_fmt_Debug_DB_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_core_clone_Clone_where_core_clone_Clone_DB_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* Clone *) + Definition clone (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context::journaled_state::JournaledState" + [ + ("database", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", DB, [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |) + ] + |)); + ("state", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |) + ] + |)); + ("transient_storage", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |) + ] + |)); + ("logs", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |) + ] + |)); + ("depth", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "usize", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) + ] + |)); + ("journal", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |)); + ("spec", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "revm_specification::hardfork::SpecId", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + ] + |)); + ("warm_preloaded_addresses", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |) + ] + |)); + ("precompiles", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::clone::Clone" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method (clone DB)) ]. + End Impl_core_clone_Clone_where_core_clone_Clone_DB_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::marker::StructuralPartialEq" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_DB_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* PartialEq *) + Definition eq (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| "core::cmp::PartialEq", DB, [ DB ], "eq", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "database" + |) + ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "state" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "logs" + |) + ] + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "depth" + |) + |) + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "revm_specification::hardfork::SpecId", + [ Ty.path "revm_specification::hardfork::SpecId" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::cmp::PartialEq" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method (eq DB)) ]. + End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_DB_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_core_cmp_Eq_where_core_cmp_Eq_DB_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* Eq *) + Definition assert_receiver_is_total_eq + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.alloc (| + Value.Tuple [] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "core::cmp::Eq" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method (assert_receiver_is_total_eq DB)) ]. + End Impl_core_cmp_Eq_where_core_cmp_Eq_DB_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_revm_context_interface_journaled_state_Journal_where_revm_database_interface_Database_DB_for_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* type Database = DB; *) + Definition _Database (DB : Ty.t) : Ty.t := DB. + + (* type FinalOutput = (EvmState, Vec); *) + Definition _FinalOutput (DB : Ty.t) : Ty.t := + Ty.tuple + [ + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ]; + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ] + ]. + + (* + fn new(database: DB) -> JournaledState { + Self::new(SpecId::LATEST, database) + } + *) + Definition new (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ database ] => + ltac:(M.monadic + (let database := M.alloc (| database |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "new", + [] + |), + [ + Value.StructTuple "revm_specification::hardfork::SpecId::LATEST" []; + M.read (| database |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn db_ref(&self) -> &Self::Database { + &self.database + } + *) + Definition db_ref (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn db(&mut self) -> &mut Self::Database { + &mut self.database + } + *) + Definition db (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sload( + &mut self, + address: Address, + key: U256, + ) -> Result, ::Error> { + self.sload(address, key) + } + *) + Definition sload (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "sload", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| key |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn sstore( + &mut self, + address: Address, + key: U256, + value: U256, + ) -> Result, ::Error> { + self.sstore(address, key, value) + } + *) + Definition sstore (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "sstore", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| key |); M.read (| value |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tload(&mut self, address: Address, key: U256) -> U256 { + self.tload(address, key) + } + *) + Definition tload (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "tload", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| key |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn tstore(&mut self, address: Address, key: U256, value: U256) { + self.tstore(address, key, value) + } + *) + Definition tstore (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key; value ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + let value := M.alloc (| value |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "tstore", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| key |); M.read (| value |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn log(&mut self, log: Log) { + self.log(log) + } + *) + Definition log (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "log", + [] + |), + [ M.read (| self |); M.read (| log |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn selfdestruct( + &mut self, + address: Address, + target: Address, + ) -> Result, DB::Error> { + self.selfdestruct(address, target) + } + *) + Definition selfdestruct (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let target := M.alloc (| target |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "selfdestruct", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| target |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn warm_account(&mut self, address: Address) { + self.warm_preloaded_addresses.insert(address); + } + *) + Definition warm_account (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |); + M.read (| address |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn warm_precompiles(&mut self, address: HashSet
) { + self.precompiles = address; + self.warm_preloaded_addresses + .extend(self.precompiles.iter()); + } + *) + Definition warm_precompiles + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |), + M.read (| address |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::collect::Extend", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "extend", + [ + Ty.apply + (Ty.path "hashbrown::set::Iter") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |); + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "iter", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |) + ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn precompile_addresses(&self) -> &HashSet
{ + &self.precompiles + } + *) + Definition precompile_addresses + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "precompiles" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn depth(&self) -> usize { + self.depth + } + *) + Definition depth (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn warm_account_and_storage( + &mut self, + address: Address, + storage_keys: impl IntoIterator, + ) -> Result<(), ::Error> { + self.initial_account_load(address, storage_keys)?; + Ok(()) + } + *) + Definition warm_account_and_storage + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [ impl_IntoIterator_Item___U256_ ], [ self; address; storage_keys ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let storage_keys := M.alloc (| storage_keys |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "initial_account_load", + [ impl_IntoIterator_Item___U256_ ] + |), + [ M.read (| self |); M.read (| address |); M.read (| storage_keys |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.tuple []; Ty.associated ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) in + M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn set_spec_id(&mut self, spec_id: SpecId) { + self.spec = spec_id; + } + *) + Definition set_spec_id (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; spec_id ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let spec_id := M.alloc (| spec_id |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |), + M.read (| spec_id |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn transfer( + &mut self, + from: &Address, + to: &Address, + balance: U256, + ) -> Result, DB::Error> { + // TODO : Handle instruction result + self.transfer(from, to, balance) + } + *) + Definition transfer (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; from; to; balance ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let from := M.alloc (| from |) in + let to := M.alloc (| to |) in + let balance := M.alloc (| balance |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "transfer", + [] + |), + [ M.read (| self |); M.read (| from |); M.read (| to |); M.read (| balance |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn touch_account(&mut self, address: Address) { + self.touch(&address); + } + *) + Definition touch_account + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "touch", + [] + |), + [ M.read (| self |); address ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn inc_account_nonce(&mut self, address: Address) -> Result, DB::Error> { + Ok(self.inc_nonce(address)) + } + *) + Definition inc_account_nonce + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "inc_nonce", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn load_account(&mut self, address: Address) -> Result, DB::Error> { + self.load_account(address) + } + *) + Definition load_account (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn load_account_code( + &mut self, + address: Address, + ) -> Result, DB::Error> { + self.load_code(address) + } + *) + Definition load_account_code + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "load_code", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn load_account_delegated(&mut self, address: Address) -> Result { + self.load_account_delegated(address) + } + *) + Definition load_account_delegated + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "load_account_delegated", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn checkpoint(&mut self) -> JournalCheckpoint { + self.checkpoint() + } + *) + Definition checkpoint (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "checkpoint", + [] + |), + [ M.read (| self |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn checkpoint_commit(&mut self) { + self.checkpoint_commit() + } + *) + Definition checkpoint_commit + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "checkpoint_commit", + [] + |), + [ M.read (| self |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn checkpoint_revert(&mut self, checkpoint: JournalCheckpoint) { + self.checkpoint_revert(checkpoint) + } + *) + Definition checkpoint_revert + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; checkpoint ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let checkpoint := M.alloc (| checkpoint |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "checkpoint_revert", + [] + |), + [ M.read (| self |); M.read (| checkpoint |) ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) { + self.set_code_with_hash(address, code, hash); + } + *) + Definition set_code_with_hash + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; code; hash ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let code := M.alloc (| code |) in + let hash := M.alloc (| hash |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "set_code_with_hash", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| code |); M.read (| hash |) ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn clear(&mut self) { + // Clears the JournaledState. Preserving only the spec. + self.state.clear(); + self.transient_storage.clear(); + self.logs.clear(); + self.journal = vec![vec![]]; + self.depth = 0; + self.warm_preloaded_addresses.clear(); + } + *) + Definition clear (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |) + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |), + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "into_vec", + [ Ty.path "alloc::alloc::Global" ] + |), + [ + M.read (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "array") + [ Value.Integer IntegerKind.Usize 1 ] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |) + ] + |) + ] + |) + |) + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |), + Value.Integer IntegerKind.Usize 0 + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "clear", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn create_account_checkpoint( + &mut self, + caller: Address, + address: Address, + balance: U256, + spec_id: SpecId, + ) -> Result { + // Ignore error. + self.create_account_checkpoint(caller, address, balance, spec_id) + } + *) + Definition create_account_checkpoint + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; caller; address; balance; spec_id ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let caller := M.alloc (| caller |) in + let address := M.alloc (| address |) in + let balance := M.alloc (| balance |) in + let spec_id := M.alloc (| spec_id |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "create_account_checkpoint", + [] + |), + [ + M.read (| self |); + M.read (| caller |); + M.read (| address |); + M.read (| balance |); + M.read (| spec_id |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn finalize(&mut self) -> Result::Error> { + let Self { + state, + transient_storage, + logs, + depth, + journal, + // kept, see [Self::new] + spec: _, + database: _, + warm_preloaded_addresses: _, + precompiles: _, + } = self; + + *transient_storage = TransientStorage::default(); + *journal = vec![vec![]]; + *depth = 0; + let state = mem::take(state); + let logs = mem::take(logs); + + Ok((state, logs)) + } + *) + Definition finalize (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "state" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "transient_storage" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "logs" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "depth" + |) in + let γ1_4 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "journal" + |) in + let γ1_5 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "spec" + |) in + let γ1_6 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "database" + |) in + let γ1_7 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |) in + let γ1_8 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournaledState", + "precompiles" + |) in + let state := M.alloc (| γ1_0 |) in + let transient_storage := M.alloc (| γ1_1 |) in + let logs := M.alloc (| γ1_2 |) in + let depth := M.alloc (| γ1_3 |) in + let journal := M.alloc (| γ1_4 |) in + let~ _ := + M.write (| + M.read (| transient_storage |), + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |) + |) in + let~ _ := + M.write (| + M.read (| journal |), + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "into_vec", + [ Ty.path "alloc::alloc::Global" ] + |), + [ + M.read (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "array") + [ Value.Integer IntegerKind.Usize 1 ] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |) + ] + |) + ] + |) + |) + ] + |) + |) in + let~ _ := M.write (| M.read (| depth |), Value.Integer IntegerKind.Usize 0 |) in + let~ state := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::mem::take", + [ + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ] + ] + |), + [ M.read (| state |) ] + |) + |) in + let~ logs := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::mem::take", + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ] + ] + |), + [ M.read (| logs |) ] + |) + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ Value.Tuple [ M.read (| state |); M.read (| logs |) ] ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + forall (DB : Ty.t), + M.IsTraitInstance + "revm_context_interface::journaled_state::Journal" + (Self DB) + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("Database", InstanceField.Ty (_Database DB)); + ("FinalOutput", InstanceField.Ty (_FinalOutput DB)); + ("new", InstanceField.Method (new DB)); + ("db_ref", InstanceField.Method (db_ref DB)); + ("db", InstanceField.Method (db DB)); + ("sload", InstanceField.Method (sload DB)); + ("sstore", InstanceField.Method (sstore DB)); + ("tload", InstanceField.Method (tload DB)); + ("tstore", InstanceField.Method (tstore DB)); + ("log", InstanceField.Method (log DB)); + ("selfdestruct", InstanceField.Method (selfdestruct DB)); + ("warm_account", InstanceField.Method (warm_account DB)); + ("warm_precompiles", InstanceField.Method (warm_precompiles DB)); + ("precompile_addresses", InstanceField.Method (precompile_addresses DB)); + ("depth", InstanceField.Method (depth DB)); + ("warm_account_and_storage", InstanceField.Method (warm_account_and_storage DB)); + ("set_spec_id", InstanceField.Method (set_spec_id DB)); + ("transfer", InstanceField.Method (transfer DB)); + ("touch_account", InstanceField.Method (touch_account DB)); + ("inc_account_nonce", InstanceField.Method (inc_account_nonce DB)); + ("load_account", InstanceField.Method (load_account DB)); + ("load_account_code", InstanceField.Method (load_account_code DB)); + ("load_account_delegated", InstanceField.Method (load_account_delegated DB)); + ("checkpoint", InstanceField.Method (checkpoint DB)); + ("checkpoint_commit", InstanceField.Method (checkpoint_commit DB)); + ("checkpoint_revert", InstanceField.Method (checkpoint_revert DB)); + ("set_code_with_hash", InstanceField.Method (set_code_with_hash DB)); + ("clear", InstanceField.Method (clear DB)); + ("create_account_checkpoint", InstanceField.Method (create_account_checkpoint DB)); + ("finalize", InstanceField.Method (finalize DB)) + ]. + End Impl_revm_context_interface_journaled_state_Journal_where_revm_database_interface_Database_DB_for_revm_context_journaled_state_JournaledState_DB. + + Module Impl_revm_context_journaled_state_JournaledState_DB. + Definition Self (DB : Ty.t) : Ty.t := + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ]. + + (* + pub fn new(spec: SpecId, database: DB) -> JournaledState { + Self { + database, + state: HashMap::default(), + transient_storage: TransientStorage::default(), + logs: Vec::new(), + journal: vec![vec![]], + depth: 0, + spec, + warm_preloaded_addresses: HashSet::default(), + precompiles: HashSet::default(), + } + } + *) + Definition new (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ spec; database ] => + ltac:(M.monadic + (let spec := M.alloc (| spec |) in + let database := M.alloc (| database |) in + Value.StructRecord + "revm_context::journaled_state::JournaledState" + [ + ("database", M.read (| database |)); + ("state", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("transient_storage", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("logs", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |)); + ("journal", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "into_vec", + [ Ty.path "alloc::alloc::Global" ] + |), + [ + M.read (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::boxed::Box") + [] + [ + Ty.apply + (Ty.path "array") + [ Value.Integer IntegerKind.Usize 1 ] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ]; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |) + ] + |) + ] + |) + |) + ] + |)); + ("depth", Value.Integer IntegerKind.Usize 0); + ("spec", M.read (| spec |)); + ("warm_preloaded_addresses", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)); + ("precompiles", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_new : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "new" (new DB). + + (* + pub fn state(&mut self) -> &mut EvmState { + &mut self.state + } + *) + Definition state (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_state : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "state" (state DB). + + (* + pub fn set_spec_id(&mut self, spec: SpecId) { + self.spec = spec; + } + *) + Definition set_spec_id (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; spec ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let spec := M.alloc (| spec |) in + M.read (| + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |), + M.read (| spec |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_set_spec_id : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "set_spec_id" (set_spec_id DB). + + (* + pub fn touch(&mut self, address: &Address) { + if let Some(account) = self.state.get_mut(address) { + Self::touch_account(self.journal.last_mut().unwrap(), address, account); + } + } + *) + Definition touch (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| address |) + ] + |) + |) in + let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let account := M.copy (| γ0_0 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + M.read (| address |); + M.read (| account |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_touch : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "touch" (touch DB). + + (* + fn touch_account(journal: &mut Vec, address: &Address, account: &mut Account) { + if !account.is_touched() { + journal.push(JournalEntry::AccountTouched { address: *address }); + account.mark_touch(); + } + } + *) + Definition touch_account + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ journal; address; account ] => + ltac:(M.monadic + (let journal := M.alloc (| journal |) in + let address := M.alloc (| address |) in + let account := M.alloc (| account |) in + M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + UnOp.not (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_touched", + [] + |), + [ M.read (| account |) ] + |) + |) + |)) in + let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.read (| journal |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountTouched" + [ ("address", M.read (| M.read (| address |) |)) ] + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_touch", + [] + |), + [ M.read (| account |) ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_touch_account : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "touch_account" (touch_account DB). + + (* + pub fn account(&self, address: Address) -> &Account { + self.state + .get(&address) + .expect("Account expected to be loaded") // Always assume that acc is already loaded + } + *) + Definition account (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&") [] [ Ty.path "revm_state::Account" ] ], + "expect", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |); + M.read (| Value.String "Account expected to be loaded" |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_account : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "account" (account DB). + + (* + pub fn set_code_with_hash(&mut self, address: Address, code: Bytecode, hash: B256) { + let account = self.state.get_mut(&address).unwrap(); + Self::touch_account(self.journal.last_mut().unwrap(), &address, account); + + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::CodeChange { address }); + + account.info.code_hash = hash; + account.info.code = Some(code); + } + *) + Definition set_code_with_hash + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; code; hash ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let code := M.alloc (| code |) in + let hash := M.alloc (| hash |) in + M.read (| + let~ account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + address; + M.read (| account |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::CodeChange" + [ ("address", M.read (| address |)) ] + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code_hash" + |), + M.read (| hash |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |), + Value.StructTuple "core::option::Option::Some" [ M.read (| code |) ] + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_set_code_with_hash : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "set_code_with_hash" (set_code_with_hash DB). + + (* + pub fn set_code(&mut self, address: Address, code: Bytecode) { + let hash = code.hash_slow(); + self.set_code_with_hash(address, code, hash) + } + *) + Definition set_code (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; code ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let code := M.alloc (| code |) in + M.read (| + let~ hash := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::bytecode::Bytecode", + "hash_slow", + [] + |), + [ code ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "set_code_with_hash", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| code |); M.read (| hash |) ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_set_code : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "set_code" (set_code DB). + + (* + pub fn inc_nonce(&mut self, address: Address) -> Option { + let account = self.state.get_mut(&address).unwrap(); + // Check if nonce is going to overflow. + if account.info.nonce == u64::MAX { + return None; + } + Self::touch_account(self.journal.last_mut().unwrap(), &address, account); + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::NonceChange { address }); + + account.info.nonce += 1; + + Some(account.info.nonce) + } + *) + Definition inc_nonce (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |) + |), + M.read (| M.get_constant (| "core::num::MAX" |) |) + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| Value.StructTuple "core::option::Option::None" [] |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + address; + M.read (| account |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::NonceChange" + [ ("address", M.read (| address |)) ] + ] + |) + |) in + let~ _ := + let β := + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |) in + M.write (| + β, + BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.U64 1 |) + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |) + |) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_inc_nonce : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "inc_nonce" (inc_nonce DB). + + (* + pub fn transfer( + &mut self, + from: &Address, + to: &Address, + balance: U256, + ) -> Result, DB::Error> { + if balance.is_zero() { + self.load_account( *to)?; + let _ = self.load_account( *to)?; + let to_account = self.state.get_mut(to).unwrap(); + Self::touch_account(self.journal.last_mut().unwrap(), to, to_account); + return Ok(None); + } + // load accounts + self.load_account( *from)?; + self.load_account( *to)?; + + // sub balance from + let from_account = &mut self.state.get_mut(from).unwrap(); + Self::touch_account(self.journal.last_mut().unwrap(), from, from_account); + let from_balance = &mut from_account.info.balance; + + let Some(from_balance_incr) = from_balance.checked_sub(balance) else { + return Ok(Some(TransferError::OutOfFunds)); + }; + *from_balance = from_balance_incr; + + // add balance to + let to_account = &mut self.state.get_mut(to).unwrap(); + Self::touch_account(self.journal.last_mut().unwrap(), to, to_account); + let to_balance = &mut to_account.info.balance; + let Some(to_balance_decr) = to_balance.checked_add(balance) else { + return Ok(Some(TransferError::OverflowPayment)); + }; + *to_balance = to_balance_decr; + // Overflow of U256 balance is not possible to happen on mainnet. We don't bother to return funds from from_acc. + + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::BalanceTransfer { + from: *from, + to: *to, + balance, + }); + + Ok(None) + } + *) + Definition transfer (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; from; to; balance ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let from := M.alloc (| from |) in + let to := M.alloc (| to |) in + let balance := M.alloc (| balance |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + "is_zero", + [] + |), + [ balance ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| M.read (| to |) |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_context_interface::journaled_state::TransferError" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) in + M.match_operator (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| M.read (| to |) |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_context_interface::journaled_state::TransferError" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |), + [ + fun γ => + ltac:(M.monadic + (let~ to_account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| to |) + ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + M.read (| to |); + M.read (| to_account |) + ] + |) + |) in + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ Value.StructTuple "core::option::Option::None" [] ] + |))) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| M.read (| from |) |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_context_interface::journaled_state::TransferError" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| M.read (| to |) |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_context_interface::journaled_state::TransferError" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) in + let~ from_account := + M.alloc (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| from |) + ] + |) + ] + |) + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + M.read (| from |); + M.read (| M.read (| from_account |) |) + ] + |) + |) in + let~ from_balance := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| M.read (| from_account |) |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |) in + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "checked_sub", + [] + |), + [ M.read (| M.read (| from_balance |) |); M.read (| balance |) ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let from_balance_incr := M.copy (| γ0_0 |) in + let~ _ := + M.write (| M.read (| from_balance |), M.read (| from_balance_incr |) |) in + let~ to_account := + M.alloc (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| to |) + ] + |) + ] + |) + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + M.read (| to |); + M.read (| M.read (| to_account |) |) + ] + |) + |) in + let~ to_balance := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| M.read (| to_account |) |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |) in + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + "checked_add", + [] + |), + [ M.read (| M.read (| to_balance |) |); M.read (| balance |) ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let to_balance_decr := M.copy (| γ0_0 |) in + let~ _ := + M.write (| + M.read (| to_balance |), + M.read (| to_balance_decr |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::BalanceTransfer" + [ + ("from", M.read (| M.read (| from |) |)); + ("to", M.read (| M.read (| to |) |)); + ("balance", M.read (| balance |)) + ] + ] + |) + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ Value.StructTuple "core::option::Option::None" [] ] + |))) + ] + |))) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_transfer : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "transfer" (transfer DB). + + (* + pub fn create_account_checkpoint( + &mut self, + caller: Address, + target_address: Address, + balance: U256, + spec_id: SpecId, + ) -> Result { + // Enter subroutine + let checkpoint = self.checkpoint(); + + // Fetch balance of caller. + let caller_acc = self.state.get_mut(&caller).unwrap(); + // Check if caller has enough balance to send to the created contract. + if caller_acc.info.balance < balance { + self.checkpoint_revert(checkpoint); + return Err(TransferError::OutOfFunds); + } + + // Newly created account is present, as we just loaded it. + let target_acc = self.state.get_mut(&target_address).unwrap(); + let last_journal = self.journal.last_mut().unwrap(); + + // New account can be created if: + // Bytecode is not empty. + // Nonce is not zero + // Account is not precompile. + if target_acc.info.code_hash != KECCAK_EMPTY || target_acc.info.nonce != 0 { + self.checkpoint_revert(checkpoint); + return Err(TransferError::CreateCollision); + } + + // set account status to created. + target_acc.mark_created(); + + // this entry will revert set nonce. + last_journal.push(JournalEntry::AccountCreated { + address: target_address, + }); + target_acc.info.code = None; + // EIP-161: State trie clearing (invariant-preserving alternative) + if spec_id.is_enabled_in(SPURIOUS_DRAGON) { + // nonce is going to be reset to zero in AccountCreated journal entry. + target_acc.info.nonce = 1; + } + + // touch account. This is important as for pre SpuriousDragon account could be + // saved even empty. + Self::touch_account(last_journal, &target_address, target_acc); + + // Add balance to created account, as we already have target here. + let Some(new_balance) = target_acc.info.balance.checked_add(balance) else { + self.checkpoint_revert(checkpoint); + return Err(TransferError::OverflowPayment); + }; + target_acc.info.balance = new_balance; + + // safe to decrement for the caller as balance check is already done. + self.state.get_mut(&caller).unwrap().info.balance -= balance; + + // add journal entry of transferred balance + last_journal.push(JournalEntry::BalanceTransfer { + from: caller, + to: target_address, + balance, + }); + + Ok(checkpoint) + } + *) + Definition create_account_checkpoint + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; caller; target_address; balance; spec_id ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let caller := M.alloc (| caller |) in + let target_address := M.alloc (| target_address |) in + let balance := M.alloc (| balance |) in + let spec_id := M.alloc (| spec_id |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ checkpoint := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "checkpoint", + [] + |), + [ M.read (| self |) ] + |) + |) in + let~ caller_acc := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + caller + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialOrd", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "lt", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| caller_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + balance + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "checkpoint_revert", + [] + |), + [ M.read (| self |); M.read (| checkpoint |) ] + |) + |) in + M.return_ (| + Value.StructTuple + "core::result::Result::Err" + [ + Value.StructTuple + "revm_context_interface::journaled_state::TransferError::OutOfFunds" + [] + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ target_acc := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + target_address + ] + |) + ] + |) + |) in + let~ last_journal := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + LogicalOp.or (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [], + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "ne", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code_hash" + |); + M.get_constant (| "revm_primitives::KECCAK_EMPTY" |) + ] + |), + ltac:(M.monadic + (BinOp.ne (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |) + |), + Value.Integer IntegerKind.U64 0 + |))) + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "checkpoint_revert", + [] + |), + [ M.read (| self |); M.read (| checkpoint |) ] + |) + |) in + M.return_ (| + Value.StructTuple + "core::result::Result::Err" + [ + Value.StructTuple + "revm_context_interface::journaled_state::TransferError::CreateCollision" + [] + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_created", + [] + |), + [ M.read (| target_acc |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.read (| last_journal |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountCreated" + [ ("address", M.read (| target_address |)) ] + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |), + Value.StructTuple "core::option::Option::None" [] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_specification::hardfork::SpecId", + "is_enabled_in", + [] + |), + [ + M.read (| spec_id |); + Value.StructTuple + "revm_specification::hardfork::SpecId::SPURIOUS_DRAGON" + [] + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |), + Value.Integer IntegerKind.U64 1 + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ M.read (| last_journal |); target_address; M.read (| target_acc |) ] + |) + |) in + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "checked_add", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |); + M.read (| balance |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let new_balance := M.copy (| γ0_0 |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |), + M.read (| new_balance |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::SubAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "sub_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + caller + ] + |) + ] + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| balance |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.read (| last_journal |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::BalanceTransfer" + [ + ("from", M.read (| caller |)); + ("to", M.read (| target_address |)); + ("balance", M.read (| balance |)) + ] + ] + |) + |) in + M.alloc (| + Value.StructTuple "core::result::Result::Ok" [ M.read (| checkpoint |) ] + |))) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_create_account_checkpoint : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "create_account_checkpoint" (create_account_checkpoint DB). + + (* + fn journal_revert( + state: &mut EvmState, + transient_storage: &mut TransientStorage, + journal_entries: Vec, + is_spurious_dragon_enabled: bool, + ) { + for entry in journal_entries.into_iter().rev() { + match entry { + JournalEntry::AccountWarmed { address } => { + state.get_mut(&address).unwrap().mark_cold(); + } + JournalEntry::AccountTouched { address } => { + if is_spurious_dragon_enabled && address == PRECOMPILE3 { + continue; + } + // remove touched status + state.get_mut(&address).unwrap().unmark_touch(); + } + JournalEntry::AccountDestroyed { + address, + target, + was_destroyed, + had_balance, + } => { + let account = state.get_mut(&address).unwrap(); + // set previous state of selfdestructed flag, as there could be multiple + // selfdestructs in one transaction. + if was_destroyed { + // flag is still selfdestructed + account.mark_selfdestruct(); + } else { + // flag that is not selfdestructed + account.unmark_selfdestruct(); + } + account.info.balance += had_balance; + + if address != target { + let target = state.get_mut(&target).unwrap(); + target.info.balance -= had_balance; + } + } + JournalEntry::BalanceTransfer { from, to, balance } => { + // we don't need to check overflow and underflow when adding and subtracting the balance. + let from = state.get_mut(&from).unwrap(); + from.info.balance += balance; + let to = state.get_mut(&to).unwrap(); + to.info.balance -= balance; + } + JournalEntry::NonceChange { address } => { + state.get_mut(&address).unwrap().info.nonce -= 1; + } + JournalEntry::AccountCreated { address } => { + let account = &mut state.get_mut(&address).unwrap(); + account.unmark_created(); + account + .storage + .values_mut() + .for_each(|slot| slot.mark_cold()); + account.info.nonce = 0; + } + JournalEntry::StorageWarmed { address, key } => { + state + .get_mut(&address) + .unwrap() + .storage + .get_mut(&key) + .unwrap() + .mark_cold(); + } + JournalEntry::StorageChanged { + address, + key, + had_value, + } => { + state + .get_mut(&address) + .unwrap() + .storage + .get_mut(&key) + .unwrap() + .present_value = had_value; + } + JournalEntry::TransientStorageChange { + address, + key, + had_value, + } => { + let tkey = (address, key); + if had_value.is_zero() { + // if previous value is zero, remove it + transient_storage.remove(&tkey); + } else { + // if not zero, reinsert old value to transient storage. + transient_storage.insert(tkey, had_value); + } + } + JournalEntry::CodeChange { address } => { + let acc = state.get_mut(&address).unwrap(); + acc.info.code_hash = KECCAK_EMPTY; + acc.info.code = None; + } + } + } + } + *) + Definition journal_revert + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ state; transient_storage; journal_entries; is_spurious_dragon_enabled ] => + ltac:(M.monadic + (let state := M.alloc (| state |) in + let transient_storage := M.alloc (| transient_storage |) in + let journal_entries := M.alloc (| journal_entries |) in + let is_spurious_dragon_enabled := M.alloc (| is_spurious_dragon_enabled |) in + M.read (| + M.use + (M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::collect::IntoIterator", + Ty.apply + (Ty.path "core::iter::adapters::rev::Rev") + [] + [ + Ty.apply + (Ty.path "alloc::vec::into_iter::IntoIter") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + [], + "into_iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "alloc::vec::into_iter::IntoIter") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + [], + "rev", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::collect::IntoIterator", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + [], + "into_iter", + [] + |), + [ M.read (| journal_entries |) ] + |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let iter := M.copy (| γ |) in + M.loop (| + ltac:(M.monadic + (let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::iter::adapters::rev::Rev") + [] + [ + Ty.apply + (Ty.path "alloc::vec::into_iter::IntoIter") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + [], + "next", + [] + |), + [ iter ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| γ, "core::option::Option::None" |) in + M.alloc (| M.never_to_any (| M.read (| M.break (||) |) |) |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + M.match_operator (| + entry, + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let address := M.copy (| γ0_0 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_cold", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let address := M.copy (| γ0_0 |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + LogicalOp.and (| + M.read (| + is_spurious_dragon_enabled + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path + "alloy_primitives::bits::address::Address", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ], + "eq", + [] + |), + [ + address; + M.get_constant (| + "revm_primitives::constants::PRECOMPILE3" + |) + ] + |))) + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + M.never_to_any (| + M.read (| M.continue (||) |) + |) + |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "unmark_touch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ0_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ0_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ0_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let address := M.copy (| γ0_0 |) in + let target := M.copy (| γ0_1 |) in + let was_destroyed := M.copy (| γ0_2 |) in + let had_balance := M.copy (| γ0_3 |) in + let~ account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := M.use was_destroyed in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_selfdestruct", + [] + |), + [ M.read (| account |) ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "unmark_selfdestruct", + [] + |), + [ M.read (| account |) ] + |) + |) in + M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::AddAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "add_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| had_balance |) + ] + |) + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path + "alloy_primitives::bits::address::Address", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ], + "ne", + [] + |), + [ address; target ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ target := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); target ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::SubAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "sub_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| had_balance |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ0_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ0_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let from := M.copy (| γ0_0 |) in + let to := M.copy (| γ0_1 |) in + let balance := M.copy (| γ0_2 |) in + let~ from := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); from ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::AddAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "add_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| from |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| balance |) + ] + |) + |) in + let~ to := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); to ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::SubAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "sub_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| to |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| balance |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let address := M.copy (| γ0_0 |) in + let~ _ := + let β := + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |) in + M.write (| + β, + BinOp.Wrap.sub (| + M.read (| β |), + Value.Integer IntegerKind.U64 1 + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let address := M.copy (| γ0_0 |) in + let~ account := + M.alloc (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |) + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "unmark_created", + [] + |), + [ M.read (| M.read (| account |) |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "hashbrown::map::ValuesMut") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot" + ], + [], + "for_each", + [ + Ty.function + [ + Ty.tuple + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::EvmStorageSlot" + ] + ] + ] + (Ty.tuple []) + ] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "values_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| M.read (| account |) |), + "revm_state::Account", + "storage" + |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let slot := M.copy (| γ |) in + M.call_closure (| + M.get_associated_function (| + Ty.path + "revm_state::EvmStorageSlot", + "mark_cold", + [] + |), + [ M.read (| slot |) ] + |))) + ] + |))) + | _ => + M.impossible "wrong number of arguments" + end)) + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| M.read (| account |) |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "nonce" + |), + Value.Integer IntegerKind.U64 0 + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ0_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let address := M.copy (| γ0_0 |) in + let key := M.copy (| γ0_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "mark_cold", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::EvmStorageSlot" + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + []; + Ty.path + "revm_state::EvmStorageSlot"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path + "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |), + "revm_state::Account", + "storage" + |); + key + ] + |) + ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ0_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ0_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let address := M.copy (| γ0_0 |) in + let key := M.copy (| γ0_1 |) in + let had_value := M.copy (| γ0_2 |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::EvmStorageSlot" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path + "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |), + "revm_state::Account", + "storage" + |); + key + ] + |) + ] + |), + "revm_state::EvmStorageSlot", + "present_value" + |), + M.read (| had_value |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ0_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ0_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let address := M.copy (| γ0_0 |) in + let key := M.copy (| γ0_1 |) in + let had_value := M.copy (| γ0_2 |) in + let~ tkey := + M.alloc (| + Value.Tuple + [ M.read (| address |); M.read (| key |) ] + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + "is_zero", + [] + |), + [ had_value ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + []; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "remove", + [ + Ty.tuple + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + [] + ] + ] + |), + [ M.read (| transient_storage |); tkey ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + []; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.read (| transient_storage |); + M.read (| tkey |); + M.read (| had_value |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let address := M.copy (| γ0_0 |) in + let~ acc := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path + "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.path + "alloy_primitives::bits::address::Address" + ] + |), + [ M.read (| state |); address ] + |) + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code_hash" + |), + M.read (| + M.get_constant (| + "revm_primitives::KECCAK_EMPTY" + |) + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |), + Value.StructTuple "core::option::Option::None" [] + |) in + M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |) in + M.alloc (| Value.Tuple [] |))) + |))) + ] + |)) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_journal_revert : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "journal_revert" (journal_revert DB). + + (* + pub fn checkpoint(&mut self) -> JournalCheckpoint { + let checkpoint = JournalCheckpoint { + log_i: self.logs.len(), + journal_i: self.journal.len(), + }; + self.depth += 1; + self.journal.push(Default::default()); + checkpoint + } + *) + Definition checkpoint (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ checkpoint := + M.alloc (| + Value.StructRecord + "revm_context_interface::journaled_state::JournalCheckpoint" + [ + ("log_i", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "len", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |) + ] + |)); + ("journal_i", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + "len", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |)) + ] + |) in + let~ _ := + let β := + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) in + M.write (| + β, + BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.Usize 1 |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |); + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + [], + "default", + [] + |), + [] + |) + ] + |) + |) in + checkpoint + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_checkpoint : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "checkpoint" (checkpoint DB). + + (* + pub fn checkpoint_commit(&mut self) { + self.depth -= 1; + } + *) + Definition checkpoint_commit + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + let~ _ := + let β := + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) in + M.write (| + β, + BinOp.Wrap.sub (| M.read (| β |), Value.Integer IntegerKind.Usize 1 |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_checkpoint_commit : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "checkpoint_commit" (checkpoint_commit DB). + + (* + pub fn checkpoint_revert(&mut self, checkpoint: JournalCheckpoint) { + let is_spurious_dragon_enabled = self.spec.is_enabled_in(SPURIOUS_DRAGON); + let state = &mut self.state; + let transient_storage = &mut self.transient_storage; + self.depth -= 1; + // iterate over last N journals sets and revert our global state + let leng = self.journal.len(); + self.journal + .iter_mut() + .rev() + .take(leng - checkpoint.journal_i) + .for_each(|cs| { + Self::journal_revert( + state, + transient_storage, + mem::take(cs), + is_spurious_dragon_enabled, + ) + }); + + self.logs.truncate(checkpoint.log_i); + self.journal.truncate(checkpoint.journal_i); + } + *) + Definition checkpoint_revert + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; checkpoint ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let checkpoint := M.alloc (| checkpoint |) in + M.read (| + let~ is_spurious_dragon_enabled := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_specification::hardfork::SpecId", + "is_enabled_in", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + |); + Value.StructTuple "revm_specification::hardfork::SpecId::SPURIOUS_DRAGON" [] + ] + |) + |) in + let~ state := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |) + |) in + let~ transient_storage := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |) + |) in + let~ _ := + let β := + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "depth" + |) in + M.write (| + β, + BinOp.Wrap.sub (| M.read (| β |), Value.Integer IntegerKind.Usize 1 |) + |) in + let~ leng := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + "len", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::iter::adapters::take::Take") + [] + [ + Ty.apply + (Ty.path "core::iter::adapters::rev::Rev") + [] + [ + Ty.apply + (Ty.path "core::slice::iter::IterMut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ] + ], + [], + "for_each", + [ + Ty.function + [ + Ty.tuple + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ] + ] + (Ty.tuple []) + ] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::iter::adapters::rev::Rev") + [] + [ + Ty.apply + (Ty.path "core::slice::iter::IterMut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + [], + "take", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.apply + (Ty.path "core::slice::iter::IterMut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + [], + "rev", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "iter_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + BinOp.Wrap.sub (| + M.read (| leng |), + M.read (| + M.SubPointer.get_struct_record_field (| + checkpoint, + "revm_context_interface::journaled_state::JournalCheckpoint", + "journal_i" + |) + |) + |) + ] + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let cs := M.copy (| γ |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "journal_revert", + [] + |), + [ + M.read (| state |); + M.read (| transient_storage |); + M.call_closure (| + M.get_function (| + "core::mem::take", + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + |), + [ M.read (| cs |) ] + |); + M.read (| is_spurious_dragon_enabled |) + ] + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "truncate", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |); + M.read (| + M.SubPointer.get_struct_record_field (| + checkpoint, + "revm_context_interface::journaled_state::JournalCheckpoint", + "log_i" + |) + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + "truncate", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |); + M.read (| + M.SubPointer.get_struct_record_field (| + checkpoint, + "revm_context_interface::journaled_state::JournalCheckpoint", + "journal_i" + |) + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_checkpoint_revert : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "checkpoint_revert" (checkpoint_revert DB). + + (* + pub fn selfdestruct( + &mut self, + address: Address, + target: Address, + ) -> Result, DB::Error> { + let spec = self.spec; + let account_load = self.load_account(target)?; + let is_cold = account_load.is_cold; + let is_empty = account_load.state_clear_aware_is_empty(spec); + + if address != target { + // Both accounts are loaded before this point, `address` as we execute its contract. + // and `target` at the beginning of the function. + let acc_balance = self.state.get_mut(&address).unwrap().info.balance; + + let target_account = self.state.get_mut(&target).unwrap(); + Self::touch_account(self.journal.last_mut().unwrap(), &target, target_account); + target_account.info.balance += acc_balance; + } + + let acc = self.state.get_mut(&address).unwrap(); + let balance = acc.info.balance; + let previously_destroyed = acc.is_selfdestructed(); + let is_cancun_enabled = self.spec.is_enabled_in(CANCUN); + + // EIP-6780 (Cancun hard-fork): selfdestruct only if contract is created in the same tx + let journal_entry = if acc.is_created() || !is_cancun_enabled { + acc.mark_selfdestruct(); + acc.info.balance = U256::ZERO; + Some(JournalEntry::AccountDestroyed { + address, + target, + was_destroyed: previously_destroyed, + had_balance: balance, + }) + } else if address != target { + acc.info.balance = U256::ZERO; + Some(JournalEntry::BalanceTransfer { + from: address, + to: target, + balance, + }) + } else { + // State is not changed: + // * if we are after Cancun upgrade and + // * Selfdestruct account that is created in the same transaction and + // * Specify the target is same as selfdestructed account. The balance stays unchanged. + None + }; + + if let Some(entry) = journal_entry { + self.journal.last_mut().unwrap().push(entry); + }; + + Ok(StateLoad { + data: SelfDestructResult { + had_value: !balance.is_zero(), + target_exists: !is_empty, + previously_destroyed, + }, + is_cold, + }) + } + *) + Definition selfdestruct (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; target ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let target := M.alloc (| target |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ spec := + M.copy (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + |) in + let~ account_load := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| target |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.path + "revm_context_interface::host::SelfDestructResult" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ is_cold := + M.copy (| + M.SubPointer.get_struct_record_field (| + account_load, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) in + let~ is_empty := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "state_clear_aware_is_empty", + [] + |), + [ + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + [], + "deref", + [] + |), + [ account_load ] + |) + |); + M.read (| spec |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::bits::address::Address", + [ Ty.path "alloy_primitives::bits::address::Address" ], + "ne", + [] + |), + [ address; target ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ acc_balance := + M.copy (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |) in + let~ target_account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + target + ] + |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "touch_account", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + target; + M.read (| target_account |) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::arith::AddAssign", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "add_assign", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| target_account |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |); + M.read (| acc_balance |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ acc := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |) + |) in + let~ balance := + M.copy (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |) + |) in + let~ previously_destroyed := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_selfdestructed", + [] + |), + [ M.read (| acc |) ] + |) + |) in + let~ is_cancun_enabled := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_specification::hardfork::SpecId", + "is_enabled_in", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + |); + Value.StructTuple "revm_specification::hardfork::SpecId::CANCUN" [] + ] + |) + |) in + let~ journal_entry := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + LogicalOp.or (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_created", + [] + |), + [ M.read (| acc |) ] + |), + ltac:(M.monadic (UnOp.not (| M.read (| is_cancun_enabled |) |))) + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_selfdestruct", + [] + |), + [ M.read (| acc |) ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |), + M.read (| M.get_constant (| "ruint::ZERO" |) |) + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountDestroyed" + [ + ("address", M.read (| address |)); + ("target", M.read (| target |)); + ("was_destroyed", M.read (| previously_destroyed |)); + ("had_balance", M.read (| balance |)) + ] + ] + |))); + fun γ => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::bits::address::Address", + [ Ty.path "alloy_primitives::bits::address::Address" + ], + "ne", + [] + |), + [ address; target ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "balance" + |), + M.read (| M.get_constant (| "ruint::ZERO" |) |) + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ + Value.StructRecord + "revm_context::journaled_state::JournalEntry::BalanceTransfer" + [ + ("from", M.read (| address |)); + ("to", M.read (| target |)); + ("balance", M.read (| balance |)) + ] + ] + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + Value.StructTuple "core::option::Option::None" [] + |))) + ] + |))) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := journal_entry in + let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + M.read (| entry |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ + ("data", + Value.StructRecord + "revm_context_interface::host::SelfDestructResult" + [ + ("had_value", + UnOp.not (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + "is_zero", + [] + |), + [ balance ] + |) + |)); + ("target_exists", UnOp.not (| M.read (| is_empty |) |)); + ("previously_destroyed", M.read (| previously_destroyed |)) + ]); + ("is_cold", M.read (| is_cold |)) + ] + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_selfdestruct : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "selfdestruct" (selfdestruct DB). + + (* + pub fn initial_account_load( + &mut self, + address: Address, + storage_keys: impl IntoIterator, + ) -> Result<&mut Account, DB::Error> { + // load or get account. + let account = match self.state.entry(address) { + Entry::Occupied(entry) => entry.into_mut(), + Entry::Vacant(vac) => vac.insert( + self.database + .basic(address)? + .map(|i| i.into()) + .unwrap_or(Account::new_not_existing()), + ), + }; + // preload storages. + for storage_key in storage_keys.into_iter() { + if let Entry::Vacant(entry) = account.storage.entry(storage_key) { + let storage = self.database.storage(address, storage_key)?; + entry.insert(EvmStorageSlot::new(storage)); + } + } + Ok(account) + } + *) + Definition initial_account_load + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [ impl_IntoIterator_Item___U256_ ], [ self; address; storage_keys ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let storage_keys := M.alloc (| storage_keys |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ account := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "entry", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| address |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Occupied", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::OccupiedEntry") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "into_mut", + [] + |), + [ M.read (| entry |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Vacant", + 0 + |) in + let vac := M.copy (| γ0_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::VacantEntry") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.read (| vac |); + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_state::Account" ], + "unwrap_or", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_state::account_info::AccountInfo" ], + "map", + [ + Ty.path "revm_state::Account"; + Ty.function + [ + Ty.tuple + [ Ty.path "revm_state::account_info::AccountInfo" + ] + ] + (Ty.path "revm_state::Account") + ] + |), + [ + M.read (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_state::account_info::AccountInfo" + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "basic", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path + "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |); + M.closure + (fun γ => + ltac:(M.monadic + match γ with + | [ α0 ] => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| α0 |), + [ + fun γ => + ltac:(M.monadic + (let i := M.copy (| γ |) in + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.path + "revm_state::account_info::AccountInfo", + [ Ty.path "revm_state::Account" ], + "into", + [] + |), + [ M.read (| i |) ] + |))) + ] + |))) + | _ => M.impossible "wrong number of arguments" + end)) + ] + |); + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "new_not_existing", + [] + |), + [] + |) + ] + |) + ] + |) + |))) + ] + |) + |) in + let~ _ := + M.use + (M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::collect::IntoIterator", + Ty.associated, + [], + "into_iter", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::collect::IntoIterator", + impl_IntoIterator_Item___U256_, + [], + "into_iter", + [] + |), + [ M.read (| storage_keys |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let iter := M.copy (| γ |) in + M.loop (| + ltac:(M.monadic + (let~ _ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::iter::traits::iterator::Iterator", + Ty.associated, + [], + "next", + [] + |), + [ iter ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| + γ, + "core::option::Option::None" + |) in + M.alloc (| + M.never_to_any (| M.read (| M.break (||) |) |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let storage_key := M.copy (| γ0_0 |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "entry", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "storage" + |); + M.read (| storage_key |) + ] + |) + |) in + let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Vacant", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + let~ storage := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + []; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "storage", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.read (| address |); + M.read (| storage_key |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path + "core::result::Result") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path + "core::result::Result") + [] + [ + Ty.path + "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::VacantEntry") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path + "foldhash::seed::fast::RandomState"; + Ty.path + "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.read (| entry |); + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "new", + [] + |), + [ M.read (| storage |) ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))) + ] + |) in + M.alloc (| Value.Tuple [] |))) + |))) + ] + |)) in + M.alloc (| Value.StructTuple "core::result::Result::Ok" [ M.read (| account |) ] |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_initial_account_load : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "initial_account_load" (initial_account_load DB). + + (* + pub fn load_account(&mut self, address: Address) -> Result, DB::Error> { + self.load_account_optional(address, false) + } + *) + Definition load_account (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "load_account_optional", + [] + |), + [ M.read (| self |); M.read (| address |); Value.Bool false ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_load_account : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "load_account" (load_account DB). + + (* + pub fn load_account_delegated(&mut self, address: Address) -> Result { + let spec = self.spec; + let account = self.load_code(address)?; + let is_empty = account.state_clear_aware_is_empty(spec); + + let mut account_load = AccountLoad { + is_empty, + load: Eip7702CodeLoad::new_not_delegated((), account.is_cold), + }; + // load delegate code if account is EIP-7702 + if let Some(Bytecode::Eip7702(code)) = &account.info.code { + let address = code.address(); + let delegate_account = self.load_account(address)?; + account_load + .load + .set_delegate_load(delegate_account.is_cold); + } + + Ok(account_load) + } + *) + Definition load_account_delegated + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ spec := + M.copy (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "spec" + |) + |) in + let~ account := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_code", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path + "revm_context_interface::journaled_state::AccountLoad"; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ is_empty := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "state_clear_aware_is_empty", + [] + |), + [ + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + [], + "deref", + [] + |), + [ account ] + |) + |); + M.read (| spec |) + ] + |) + |) in + let~ account_load := + M.alloc (| + Value.StructRecord + "revm_context_interface::journaled_state::AccountLoad" + [ + ("is_empty", M.read (| is_empty |)); + ("load", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ], + "new_not_delegated", + [] + |), + [ + Value.Tuple []; + M.read (| + M.SubPointer.get_struct_record_field (| + account, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |)) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ], + [], + "deref", + [] + |), + [ account ] + |) + |), + "revm_state::Account", + "info" + |), + "revm_state::account_info::AccountInfo", + "code" + |) + |) in + let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let γ2_0 := + M.SubPointer.get_struct_tuple_field (| + γ1_0, + "revm_bytecode::bytecode::Bytecode::Eip7702", + 0 + |) in + let code := M.alloc (| γ2_0 |) in + let~ address := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_bytecode::eip7702::Eip7702Bytecode", + "address", + [] + |), + [ M.read (| code |) ] + |) + |) in + let~ delegate_account := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ Ty.path "revm_state::Account" ] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "load_account", + [] + |), + [ M.read (| self |); M.read (| address |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path + "revm_context_interface::journaled_state::AccountLoad"; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::Eip7702CodeLoad") + [] + [ Ty.tuple [] ], + "set_delegate_load", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + account_load, + "revm_context_interface::journaled_state::AccountLoad", + "load" + |); + M.read (| + M.SubPointer.get_struct_record_field (| + delegate_account, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| + Value.StructTuple "core::result::Result::Ok" [ M.read (| account_load |) ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_load_account_delegated : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "load_account_delegated" (load_account_delegated DB). + + (* + pub fn load_code(&mut self, address: Address) -> Result, DB::Error> { + self.load_account_optional(address, true) + } + *) + Definition load_code (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "revm_context::journaled_state::JournaledState") [] [ DB ], + "load_account_optional", + [] + |), + [ M.read (| self |); M.read (| address |); Value.Bool true ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_load_code : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "load_code" (load_code DB). + + (* + pub fn load_account_optional( + &mut self, + address: Address, + load_code: bool, + ) -> Result, DB::Error> { + let load = match self.state.entry(address) { + Entry::Occupied(entry) => { + let account = entry.into_mut(); + let is_cold = account.mark_warm(); + StateLoad { + data: account, + is_cold, + } + } + Entry::Vacant(vac) => { + let account = if let Some(account) = self.database.basic(address)? { + account.into() + } else { + Account::new_not_existing() + }; + + // precompiles are warm loaded so we need to take that into account + let is_cold = !self.warm_preloaded_addresses.contains(&address); + + StateLoad { + data: vac.insert(account), + is_cold, + } + } + }; + // journal loading of cold account. + if load.is_cold { + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::AccountWarmed { address }); + } + if load_code { + let info = &mut load.data.info; + if info.code.is_none() { + if info.code_hash == KECCAK_EMPTY { + let empty = Bytecode::default(); + info.code = Some(empty); + } else { + let code = self.database.code_by_hash(info.code_hash)?; + info.code = Some(code); + } + } + } + + Ok(load) + } + *) + Definition load_account_optional + (DB : Ty.t) + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; load_code ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let load_code := M.alloc (| load_code |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ load := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "entry", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + M.read (| address |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Occupied", + 0 + |) in + let entry := M.copy (| γ0_0 |) in + let~ account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::OccupiedEntry") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "into_mut", + [] + |), + [ M.read (| entry |) ] + |) + |) in + let~ is_cold := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "mark_warm", + [] + |), + [ M.read (| account |) ] + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ ("data", M.read (| account |)); ("is_cold", M.read (| is_cold |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Vacant", + 0 + |) in + let vac := M.copy (| γ0_0 |) in + let~ account := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.path + "revm_state::account_info::AccountInfo" + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "basic", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.read (| address |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ] + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path + "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) in + let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let account := M.copy (| γ0_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::convert::Into", + Ty.path "revm_state::account_info::AccountInfo", + [ Ty.path "revm_state::Account" ], + "into", + [] + |), + [ M.read (| account |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "new_not_existing", + [] + |), + [] + |) + |))) + ] + |) + |) in + let~ is_cold := + M.alloc (| + UnOp.not (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::set::HashSet") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "contains", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "warm_preloaded_addresses" + |); + address + ] + |) + |) + |) in + M.alloc (| + Value.StructRecord + "revm_context_interface::journaled_state::StateLoad" + [ + ("data", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::VacantEntry") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ M.read (| vac |); M.read (| account |) ] + |)); + ("is_cold", M.read (| is_cold |)) + ] + |))) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.SubPointer.get_struct_record_field (| + load, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountWarmed" + [ ("address", M.read (| address |)) ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := M.use load_code in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + let~ info := + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| + M.SubPointer.get_struct_record_field (| + load, + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |), + "revm_state::Account", + "info" + |) + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.path "revm_bytecode::bytecode::Bytecode" ], + "is_none", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| info |), + "revm_state::account_info::AccountInfo", + "code" + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [], + [ + Ty.apply + (Ty.path + "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| info |), + "revm_state::account_info::AccountInfo", + "code_hash" + |); + M.get_constant (| + "revm_primitives::KECCAK_EMPTY" + |) + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ empty := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "revm_bytecode::bytecode::Bytecode", + [], + "default", + [] + |), + [] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| info |), + "revm_state::account_info::AccountInfo", + "code" + |), + Value.StructTuple + "core::option::Option::Some" + [ M.read (| empty |) ] + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => + ltac:(M.monadic + (let~ code := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path + "revm_bytecode::bytecode::Bytecode"; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "code_by_hash", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| info |), + "revm_state::account_info::AccountInfo", + "code_hash" + |) + |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.path + "revm_state::Account" + ] + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path + "core::result::Result") + [] + [ + Ty.path + "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| info |), + "revm_state::account_info::AccountInfo", + "code" + |), + Value.StructTuple + "core::option::Option::Some" + [ M.read (| code |) ] + |) in + M.alloc (| Value.Tuple [] |))) + ] + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| Value.StructTuple "core::result::Result::Ok" [ M.read (| load |) ] |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_load_account_optional : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "load_account_optional" (load_account_optional DB). + + (* + pub fn sload(&mut self, address: Address, key: U256) -> Result, DB::Error> { + // assume acc is warm + let account = self.state.get_mut(&address).unwrap(); + // only if account is created in this tx we can assume that storage is empty. + let is_newly_created = account.is_created(); + let (value, is_cold) = match account.storage.entry(key) { + Entry::Occupied(occ) => { + let slot = occ.into_mut(); + let is_cold = slot.mark_warm(); + (slot.present_value, is_cold) + } + Entry::Vacant(vac) => { + // if storage was cleared, we don't need to ping db. + let value = if is_newly_created { + U256::ZERO + } else { + self.database.storage(address, key)? + }; + + vac.insert(EvmStorageSlot::new(value)); + + (value, true) + } + }; + + if is_cold { + // add it to journal as cold loaded. + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::StorageWarmed { address, key }); + } + + Ok(StateLoad::new(value, is_cold)) + } + *) + Definition sload (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ account := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |) + |) in + let~ is_newly_created := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::Account", + "is_created", + [] + |), + [ M.read (| account |) ] + |) + |) in + M.match_operator (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "entry", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| account |), + "revm_state::Account", + "storage" + |); + M.read (| key |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Occupied", + 0 + |) in + let occ := M.copy (| γ0_0 |) in + let~ slot := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::OccupiedEntry") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "into_mut", + [] + |), + [ M.read (| occ |) ] + |) + |) in + let~ is_cold := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "mark_warm", + [] + |), + [ M.read (| slot |) ] + |) + |) in + M.alloc (| + Value.Tuple + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| slot |), + "revm_state::EvmStorageSlot", + "present_value" + |) + |); + M.read (| is_cold |) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "hashbrown::map::Entry::Vacant", + 0 + |) in + let vac := M.copy (| γ0_0 |) in + let~ value := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := M.use is_newly_created in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.get_constant (| "ruint::ZERO" |))); + fun γ => + ltac:(M.monadic + (M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "revm_database_interface::Database", + DB, + [], + "storage", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "database" + |); + M.read (| address |); + M.read (| key |) + ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer + IntegerKind.Usize + 256; + Value.Integer + IntegerKind.Usize + 4 + ] + [] + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "core::convert::Infallible"; + Ty.associated + ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |))) + ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::VacantEntry") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.read (| vac |); + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "new", + [] + |), + [ M.read (| value |) ] + |) + ] + |) + |) in + M.alloc (| Value.Tuple [ M.read (| value |); Value.Bool true ] |))) + ] + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let value := M.copy (| γ0_0 |) in + let is_cold := M.copy (| γ0_1 |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := M.use is_cold in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::StorageWarmed" + [ + ("address", M.read (| address |)); + ("key", M.read (| key |)) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "new", + [] + |), + [ M.read (| value |); M.read (| is_cold |) ] + |) + ] + |))) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_sload : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "sload" (sload DB). + + (* + pub fn sstore( + &mut self, + address: Address, + key: U256, + new: U256, + ) -> Result, DB::Error> { + // assume that acc exists and load the slot. + let present = self.sload(address, key)?; + let acc = self.state.get_mut(&address).unwrap(); + + // if there is no original value in dirty return present value, that is our original. + let slot = acc.storage.get_mut(&key).unwrap(); + + // new value is same as present, we don't need to do anything + if present.data == new { + return Ok(StateLoad::new( + SStoreResult { + original_value: slot.original_value(), + present_value: present.data, + new_value: new, + }, + present.is_cold, + )); + } + + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::StorageChanged { + address, + key, + had_value: present.data, + }); + // insert value into present state. + slot.present_value = new; + Ok(StateLoad::new( + SStoreResult { + original_value: slot.original_value(), + present_value: present.data, + new_value: new, + }, + present.is_cold, + )) + } + *) + Definition sstore (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key; new ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + let new := M.alloc (| new |) in + M.catch_return (| + ltac:(M.monadic + (M.read (| + let~ present := + M.copy (| + M.match_operator (| + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::Try", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.associated + ], + [], + "branch", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context::journaled_state::JournaledState") + [] + [ DB ], + "sload", + [] + |), + [ M.read (| self |); M.read (| address |); M.read (| key |) ] + |) + ] + |) + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Break", + 0 + |) in + let residual := M.copy (| γ0_0 |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + M.call_closure (| + M.get_trait_method (| + "core::ops::try_trait::FromResidual", + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SStoreResult" + ]; + Ty.associated + ], + [ + Ty.apply + (Ty.path "core::result::Result") + [] + [ Ty.path "core::convert::Infallible"; Ty.associated ] + ], + "from_residual", + [] + |), + [ M.read (| residual |) ] + |) + |) + |) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::ops::control_flow::ControlFlow::Continue", + 0 + |) in + let val := M.copy (| γ0_0 |) in + val)) + ] + |) + |) in + let~ acc := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::Account" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.path "revm_state::Account"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ Ty.path "alloy_primitives::bits::address::Address" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "state" + |); + address + ] + |) + ] + |) + |) in + let~ slot := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ Ty.apply (Ty.path "&mut") [] [ Ty.path "revm_state::EvmStorageSlot" ] ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "revm_state::EvmStorageSlot"; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get_mut", + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| acc |), + "revm_state::Account", + "storage" + |); + key + ] + |) + ] + |) + |) in + let~ _ := + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "data" + |); + new + ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.never_to_any (| + M.read (| + M.return_ (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path + "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SStoreResult" + ], + "new", + [] + |), + [ + Value.StructRecord + "revm_context_interface::host::SStoreResult" + [ + ("original_value", + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "original_value", + [] + |), + [ M.read (| slot |) ] + |)); + ("present_value", + M.read (| + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |)); + ("new_value", M.read (| new |)) + ]; + M.read (| + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |) + |) + |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::StorageChanged" + [ + ("address", M.read (| address |)); + ("key", M.read (| key |)); + ("had_value", + M.read (| + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |)) + ] + ] + |) + |) in + let~ _ := + M.write (| + M.SubPointer.get_struct_record_field (| + M.read (| slot |), + "revm_state::EvmStorageSlot", + "present_value" + |), + M.read (| new |) + |) in + M.alloc (| + Value.StructTuple + "core::result::Result::Ok" + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "revm_context_interface::journaled_state::StateLoad") + [] + [ Ty.path "revm_context_interface::host::SStoreResult" ], + "new", + [] + |), + [ + Value.StructRecord + "revm_context_interface::host::SStoreResult" + [ + ("original_value", + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_state::EvmStorageSlot", + "original_value", + [] + |), + [ M.read (| slot |) ] + |)); + ("present_value", + M.read (| + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "data" + |) + |)); + ("new_value", M.read (| new |)) + ]; + M.read (| + M.SubPointer.get_struct_record_field (| + present, + "revm_context_interface::journaled_state::StateLoad", + "is_cold" + |) + |) + ] + |) + ] + |) + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_sstore : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "sstore" (sstore DB). + + (* + pub fn tload(&mut self, address: Address, key: U256) -> U256 { + self.transient_storage + .get(&(address, key)) + .copied() + .unwrap_or_default() + } + *) + Definition tload (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "unwrap_or_default", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "copied", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "get", + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |); + M.alloc (| Value.Tuple [ M.read (| address |); M.read (| key |) ] |) + ] + |) + ] + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_tload : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "tload" (tload DB). + + (* + pub fn tstore(&mut self, address: Address, key: U256, new: U256) { + let had_value = if new.is_zero() { + // if new values is zero, remove entry from transient storage. + // if previous values was some insert it inside journal. + // If it is none nothing should be inserted. + self.transient_storage.remove(&(address, key)) + } else { + // insert values + let previous_value = self + .transient_storage + .insert((address, key), new) + .unwrap_or_default(); + + // check if previous value is same + if previous_value != new { + // if it is different, insert previous values inside journal. + Some(previous_value) + } else { + None + } + }; + + if let Some(had_value) = had_value { + // insert in journal only if value was changed. + self.journal + .last_mut() + .unwrap() + .push(JournalEntry::TransientStorageChange { + address, + key, + had_value, + }); + } + } + *) + Definition tstore (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; address; key; new ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let address := M.alloc (| address |) in + let key := M.alloc (| key |) in + let new := M.alloc (| new |) in + M.read (| + let~ had_value := + M.copy (| + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + "is_zero", + [] + |), + [ new ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "remove", + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |); + M.alloc (| Value.Tuple [ M.read (| address |); M.read (| key |) ] |) + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let~ previous_value := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "unwrap_or_default", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "hashbrown::map::HashMap") + [] + [ + Ty.tuple + [ + Ty.path "alloy_primitives::bits::address::Address"; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ]; + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + []; + Ty.path "foldhash::seed::fast::RandomState"; + Ty.path "hashbrown::raw::alloc::inner::Global" + ], + "insert", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "transient_storage" + |); + Value.Tuple [ M.read (| address |); M.read (| key |) ]; + M.read (| new |) + ] + |) + ] + |) + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := + M.use + (M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "ne", + [] + |), + [ previous_value; new ] + |) + |)) in + let _ := + M.is_constant_or_break_match (| + M.read (| γ |), + Value.Bool true + |) in + M.alloc (| + Value.StructTuple + "core::option::Option::Some" + [ M.read (| previous_value |) ] + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| Value.StructTuple "core::option::Option::None" [] |))) + ] + |))) + ] + |) + |) in + M.match_operator (| + M.alloc (| Value.Tuple [] |), + [ + fun γ => + ltac:(M.monadic + (let γ := had_value in + let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "core::option::Option::Some", + 0 + |) in + let had_value := M.copy (| γ0_0 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "&mut") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ] + ], + "unwrap", + [] + |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "slice") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ] + ], + "last_mut", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::DerefMut", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.path + "revm_context::journaled_state::JournalEntry"; + Ty.path "alloc::alloc::Global" + ]; + Ty.path "alloc::alloc::Global" + ], + [], + "deref_mut", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "journal" + |) + ] + |) + ] + |) + ] + |); + Value.StructRecord + "revm_context::journaled_state::JournalEntry::TransientStorageChange" + [ + ("address", M.read (| address |)); + ("key", M.read (| key |)); + ("had_value", M.read (| had_value |)) + ] + ] + |) + |) in + M.alloc (| Value.Tuple [] |))); + fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_tstore : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "tstore" (tstore DB). + + (* + pub fn log(&mut self, log: Log) { + self.logs.push(log); + } + *) + Definition log (DB : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + let Self : Ty.t := Self DB in + match ε, τ, α with + | [], [], [ self; log ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let log := M.alloc (| log |) in + M.read (| + let~ _ := + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::log::Log") + [] + [ Ty.path "alloy_primitives::log::LogData" ]; + Ty.path "alloc::alloc::Global" + ], + "push", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::journaled_state::JournaledState", + "logs" + |); + M.read (| log |) + ] + |) + |) in + M.alloc (| Value.Tuple [] |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom AssociatedFunction_log : + forall (DB : Ty.t), + M.IsAssociatedFunction (Self DB) "log" (log DB). + End Impl_revm_context_journaled_state_JournaledState_DB. + + (* + Enum JournalEntry + { + const_params := []; + ty_params := []; + variants := + [ + { + name := "AccountWarmed"; + item := StructRecord [ ("address", Ty.path "alloy_primitives::bits::address::Address") ]; + discriminant := None; + }; + { + name := "AccountDestroyed"; + item := + StructRecord + [ + ("address", Ty.path "alloy_primitives::bits::address::Address"); + ("target", Ty.path "alloy_primitives::bits::address::Address"); + ("was_destroyed", Ty.path "bool"); + ("had_balance", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + }; + { + name := "AccountTouched"; + item := StructRecord [ ("address", Ty.path "alloy_primitives::bits::address::Address") ]; + discriminant := None; + }; + { + name := "BalanceTransfer"; + item := + StructRecord + [ + ("from", Ty.path "alloy_primitives::bits::address::Address"); + ("to", Ty.path "alloy_primitives::bits::address::Address"); + ("balance", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + }; + { + name := "NonceChange"; + item := StructRecord [ ("address", Ty.path "alloy_primitives::bits::address::Address") ]; + discriminant := None; + }; + { + name := "AccountCreated"; + item := StructRecord [ ("address", Ty.path "alloy_primitives::bits::address::Address") ]; + discriminant := None; + }; + { + name := "StorageChanged"; + item := + StructRecord + [ + ("address", Ty.path "alloy_primitives::bits::address::Address"); + ("key", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("had_value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + }; + { + name := "StorageWarmed"; + item := + StructRecord + [ + ("address", Ty.path "alloy_primitives::bits::address::Address"); + ("key", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + }; + { + name := "TransientStorageChange"; + item := + StructRecord + [ + ("address", Ty.path "alloy_primitives::bits::address::Address"); + ("key", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("had_value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []) + ]; + discriminant := None; + }; + { + name := "CodeChange"; + item := StructRecord [ ("address", Ty.path "alloy_primitives::bits::address::Address") ]; + discriminant := None; + } + ]; + } + *) + + Module Impl_core_fmt_Debug_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "AccountWarmed" |); + M.read (| Value.String "address" |); + __self_0 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field4_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "AccountDestroyed" |); + M.read (| Value.String "address" |); + M.read (| __self_0 |); + M.read (| Value.String "target" |); + M.read (| __self_1 |); + M.read (| Value.String "was_destroyed" |); + M.read (| __self_2 |); + M.read (| Value.String "had_balance" |); + __self_3 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "AccountTouched" |); + M.read (| Value.String "address" |); + __self_0 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field3_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "BalanceTransfer" |); + M.read (| Value.String "from" |); + M.read (| __self_0 |); + M.read (| Value.String "to" |); + M.read (| __self_1 |); + M.read (| Value.String "balance" |); + __self_2 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "NonceChange" |); + M.read (| Value.String "address" |); + __self_0 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "AccountCreated" |); + M.read (| Value.String "address" |); + __self_0 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field3_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "StorageChanged" |); + M.read (| Value.String "address" |); + M.read (| __self_0 |); + M.read (| Value.String "key" |); + M.read (| __self_1 |); + M.read (| Value.String "had_value" |); + __self_2 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field2_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "StorageWarmed" |); + M.read (| Value.String "address" |); + M.read (| __self_0 |); + M.read (| Value.String "key" |); + __self_1 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field3_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "TransientStorageChange" |); + M.read (| Value.String "address" |); + M.read (| __self_0 |); + M.read (| Value.String "key" |); + M.read (| __self_1 |); + M.read (| Value.String "had_value" |); + __self_2 + ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_field1_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "CodeChange" |); + M.read (| Value.String "address" |); + __self_0 + ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_journaled_state_JournalEntry. + + Module Impl_core_clone_Clone_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountWarmed" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountDestroyed" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("target", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)); + ("was_destroyed", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "bool", + [], + "clone", + [] + |), + [ M.read (| __self_2 |) ] + |)); + ("had_balance", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_3 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountTouched" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::BalanceTransfer" + [ + ("from", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("to", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)); + ("balance", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_2 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::NonceChange" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::AccountCreated" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::StorageChanged" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("key", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)); + ("had_value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_2 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::StorageWarmed" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("key", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::TransientStorageChange" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)); + ("key", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_1 |) ] + |)); + ("had_value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "clone", + [] + |), + [ M.read (| __self_2 |) ] + |)) + ] + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + Value.StructRecord + "revm_context::journaled_state::JournalEntry::CodeChange" + [ + ("address", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ M.read (| __self_0 |) ] + |)) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_journaled_state_JournalEntry. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_journaled_state_JournalEntry. + + Module Impl_core_cmp_PartialEq_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context::journaled_state::JournalEntry" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ __arg1_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context::journaled_state::JournalEntry" ] + |), + [ M.read (| other |) ] + |) + |) in + M.alloc (| + LogicalOp.and (| + BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |), + ltac:(M.monadic + (M.read (| + M.match_operator (| + M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ2_3 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let __self_2 := M.alloc (| γ2_2 |) in + let __self_3 := M.alloc (| γ2_3 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ2_3 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + let __arg1_2 := M.alloc (| γ2_2 |) in + let __arg1_3 := M.alloc (| γ2_3 |) in + M.alloc (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "&") [] [ Ty.path "bool" ], + [ Ty.apply (Ty.path "&") [] [ Ty.path "bool" ] ], + "eq", + [] + |), + [ __self_2; __arg1_2 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_3; __arg1_3 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let __self_2 := M.alloc (| γ2_2 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + let __arg1_2 := M.alloc (| γ2_2 |) in + M.alloc (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_2; __arg1_2 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let __self_2 := M.alloc (| γ2_2 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + let __arg1_2 := M.alloc (| γ2_2 |) in + M.alloc (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_2; __arg1_2 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + M.alloc (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let __self_1 := M.alloc (| γ2_1 |) in + let __self_2 := M.alloc (| γ2_2 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ2_1 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ2_2 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + let __arg1_1 := M.alloc (| γ2_1 |) in + let __arg1_2 := M.alloc (| γ2_2 |) in + M.alloc (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_1; __arg1_1 ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "&") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ __self_2; __arg1_2 ] + |))) + |) + |))); + fun γ => + ltac:(M.monadic + (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in + let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in + let γ0_0 := M.read (| γ0_0 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_0, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let __self_0 := M.alloc (| γ2_0 |) in + let γ0_1 := M.read (| γ0_1 |) in + let γ2_0 := + M.SubPointer.get_struct_record_field (| + γ0_1, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let __arg1_0 := M.alloc (| γ2_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ], + [ + Ty.apply + (Ty.path "&") + [] + [ Ty.path "alloy_primitives::bits::address::Address" ] + ], + "eq", + [] + |), + [ __self_0; __arg1_0 ] + |) + |))); + fun γ => + ltac:(M.monadic + (M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::intrinsics::unreachable", [] |), + [] + |) + |) + |))) + ] + |) + |))) + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_journaled_state_JournalEntry. + + Module Impl_core_cmp_Eq_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_journaled_state_JournalEntry. + + Module Impl_core_hash_Hash_for_revm_context_journaled_state_JournalEntry. + Definition Self : Ty.t := Ty.path "revm_context::journaled_state::JournalEntry". + + (* Hash *) + Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [ __H ], [ self; state ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let state := M.alloc (| state |) in + M.read (| + let~ __self_discr := + M.alloc (| + M.call_closure (| + M.get_function (| + "core::intrinsics::discriminant_value", + [ Ty.path "revm_context::journaled_state::JournalEntry" ] + |), + [ M.read (| self |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |), + [ __self_discr; M.read (| state |) ] + |) + |) in + M.match_operator (| + self, + [ + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountWarmed", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "target" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "was_destroyed" + |) in + let γ1_3 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountDestroyed", + "had_balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let __self_3 := M.alloc (| γ1_3 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "bool", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_2 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_3 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountTouched", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "from" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "to" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::BalanceTransfer", + "balance" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_2 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::NonceChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::AccountCreated", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageChanged", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_2 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::StorageWarmed", + "key" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "address" + |) in + let γ1_1 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "key" + |) in + let γ1_2 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::TransientStorageChange", + "had_value" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + let __self_1 := M.alloc (| γ1_1 |) in + let __self_2 := M.alloc (| γ1_2 |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |) in + let~ _ := + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_1 |); M.read (| state |) ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [], + [], + "hash", + [ __H ] + |), + [ M.read (| __self_2 |); M.read (| state |) ] + |) + |))); + fun γ => + ltac:(M.monadic + (let γ := M.read (| γ |) in + let γ1_0 := + M.SubPointer.get_struct_record_field (| + γ, + "revm_context::journaled_state::JournalEntry::CodeChange", + "address" + |) in + let __self_0 := M.alloc (| γ1_0 |) in + M.alloc (| + M.call_closure (| + M.get_trait_method (| + "core::hash::Hash", + Ty.path "alloy_primitives::bits::address::Address", + [], + "hash", + [ __H ] + |), + [ M.read (| __self_0 |); M.read (| state |) ] + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::hash::Hash" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("hash", InstanceField.Method hash) ]. + End Impl_core_hash_Hash_for_revm_context_journaled_state_JournalEntry. +End journaled_state. diff --git a/CoqOfRust/revm/translations/context/tx.json b/CoqOfRust/revm/translations/context/tx.json new file mode 100644 index 000000000..57e76684c --- /dev/null +++ b/CoqOfRust/revm/translations/context/tx.json @@ -0,0 +1,10709 @@ +[ + { + "file_name": "crates/context/src/tx.rs", + "item": { + "Module": { + "name": "tx", + "body": [ + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TypeStructStruct": { + "name": "TxEnv", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "tx_type", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "caller", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "gas_limit", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "gas_price", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "transact_to", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "value", + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + [ + "data", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "nonce", + { + "Path": { + "path": [ + "u64" + ] + } + } + ], + [ + "chain_id", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + [ + "access_list", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "gas_priority_fee", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + [ + "blob_hashes", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + [ + "max_fee_per_blob_gas", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + [ + "authorization_list", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ], + "fields": [ + [ + "tx_type", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "tx_type" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "caller", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "caller" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_limit", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_price", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "transact_to", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "value", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "data", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "nonce", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "chain_id", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "access_list", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "gas_priority_fee", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_priority_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "blob_hashes", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "blob_hashes" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "max_fee_per_blob_gas", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "max_fee_per_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "authorization_list", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "names", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "tx_type" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "caller" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_limit" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_price" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "transact_to" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "value" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "data" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "nonce" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "chain_id" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "access_list" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "gas_priority_fee" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "blob_hashes" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "max_fee_per_blob_gas" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "authorization_list" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "values", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "tx_type" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "caller" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_priority_fee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "blob_hashes" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "max_fee_per_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_fields_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "TxEnv" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "names" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "values" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "tx_type" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "tx_type" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "caller" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "caller" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "value" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_priority_fee" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_priority_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "blob_hashes" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "blob_hashes" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "max_fee_per_blob_gas" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "max_fee_per_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + " fn default() -> Self {", + " Self {", + " tx_type: TransactionType::Legacy,", + " caller: Address::default(),", + " gas_limit: 30_000_000,", + " gas_price: U256::ZERO,", + " transact_to: TxKind::Call(Address::default()),", + " value: U256::ZERO,", + " data: Bytes::default(),", + " nonce: 0,", + " chain_id: Some(1), // Mainnet chain ID is 1", + " access_list: AccessList::default(),", + " gas_priority_fee: Some(U256::ZERO),", + " blob_hashes: Vec::new(),", + " max_fee_per_blob_gas: Some(U256::ZERO),", + " authorization_list: AuthorizationList::default(),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ], + "fields": [ + [ + "tx_type", + { + "StructTuple": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType", + "Legacy" + ], + "fields": [] + } + } + ], + [ + "caller", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "gas_limit", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 30000000 + } + } + } + ], + [ + "gas_price", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "transact_to", + { + "StructTuple": { + "path": [ + "alloy_primitives", + "common", + "TxKind", + "Call" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + ], + [ + "value", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ], + [ + "data", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "nonce", + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 0 + } + } + } + ], + [ + "chain_id", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ] + } + } + ], + [ + "access_list", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "gas_priority_fee", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + [ + "blob_hashes", + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + [ + "max_fee_per_blob_gas", + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "ruint", + "ZERO" + ] + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + [ + "authorization_list", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "default", + "Default" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "default", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "common", + "CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "caller", + "snippet": [ + " fn caller(&self) -> Address {", + " self.caller", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "caller" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_limit", + "snippet": [ + " fn gas_limit(&self) -> u64 {", + " self.gas_limit", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_limit" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "value", + "snippet": [ + " fn value(&self) -> U256 {", + " self.value", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "value" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "input", + "snippet": [ + " fn input(&self) -> &Bytes {", + " &self.data", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bytes_", + "Bytes" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "data" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "nonce", + "snippet": [ + " fn nonce(&self) -> u64 {", + " self.nonce", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "nonce" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559CommonTxFields" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + " type AccessList = AccessList;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + " fn chain_id(&self) -> u64 {", + " self.chain_id.unwrap_or_default()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_gas", + "snippet": [ + " fn max_fee_per_gas(&self) -> u128 {", + " self.gas_price.to()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "to", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_priority_fee_per_gas", + "snippet": [ + " fn max_priority_fee_per_gas(&self) -> u128 {", + " self.gas_priority_fee.unwrap_or_default().to()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "to", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_priority_fee" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + " fn access_list(&self) -> &Self::AccessList {", + " &self.access_list", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "legacy", + "LegacyTx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + " fn kind(&self) -> TxKind {", + " self.transact_to", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + " fn chain_id(&self) -> Option {", + " self.chain_id", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + " fn gas_price(&self) -> u128 {", + " self.gas_price.try_into().unwrap_or(u128::MAX)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "from", + "FromUintError" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + } + ] + } + }, + "func": "unwrap_or", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "TryInto" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "trait_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ], + "method_name": "try_into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "core", + "num", + "MAX" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip2930", + "Eip2930Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "AccessList", + "snippet": [ + " type AccessList = AccessList;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip2930", + "AccessList" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "access_list", + "snippet": [ + " fn access_list(&self) -> &Self::AccessList {", + " &self.access_list", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "access_list" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "chain_id", + "snippet": [ + " fn chain_id(&self) -> u64 {", + " self.chain_id.unwrap_or_default()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u64" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "u64" + ] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "chain_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "gas_price", + "snippet": [ + " fn gas_price(&self) -> u128 {", + " self.gas_price.to()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "to", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "gas_price" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "kind", + "snippet": [ + " fn kind(&self) -> TxKind {", + " self.transact_to", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip1559", + "Eip1559Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "kind", + "snippet": [ + " fn kind(&self) -> TxKind {", + " self.transact_to", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "common", + "TxKind" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip4844", + "Eip4844Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + " fn destination(&self) -> Address {", + " match self.transact_to {", + " TxKind::Call(addr) => addr,", + " TxKind::Create => panic!(\"Create transaction are not allowed in Eip4844\"),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "alloy_primitives::common::TxKind::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "addr", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "addr" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "alloy_primitives::common::TxKind::Create" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Create transaction are not allowed in Eip4844" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "blob_versioned_hashes", + "snippet": [ + " fn blob_versioned_hashes(&self) -> &[B256] {", + " &self.blob_hashes", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "fixed", + "FixedBytes" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 32 + } + } + } + ], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "blob_hashes" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "max_fee_per_blob_gas", + "snippet": [ + " fn max_fee_per_blob_gas(&self) -> u128 {", + " self.max_fee_per_blob_gas.unwrap_or_default().to()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "u128" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "to", + "generic_tys": [ + { + "Path": { + "path": [ + "u128" + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + } + ] + } + }, + "func": "unwrap_or_default", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "max_fee_per_blob_gas" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "total_blob_gas", + "snippet": null, + "kind": "Default" + }, + { + "name": "calc_max_data_fee", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "eip7702", + "Eip7702Tx" + ], + "trait_ty_params": [], + "items": [ + { + "name": "destination", + "snippet": [ + " fn destination(&self) -> Address {", + " match self.transact_to {", + " TxKind::Call(addr) => addr,", + " TxKind::Create => panic!(\"Create transaction are not allowed in Eip7702\"),", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "transact_to" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "alloy_primitives::common::TxKind::Call" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "addr", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LocalVar": "addr" + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "alloy_primitives::common::TxKind::Create" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "panicking", + "panic_fmt" + ], + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_const", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Create transaction are not allowed in Eip7702" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_len", + "snippet": [ + " fn authorization_list_len(&self) -> usize {", + " self.authorization_list.len()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + }, + { + "name": "authorization_list_iter", + "snippet": [ + " fn authorization_list_iter(&self) -> impl Iterator {", + " self.authorization_list.recovered_iter()", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "recovered_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "authorization_list" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/context/src/tx.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "revm_context_interface", + "transaction", + "Transaction" + ], + "trait_ty_params": [], + "items": [ + { + "name": "TransactionError", + "snippet": [ + " type TransactionError = InvalidTransaction;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "result", + "InvalidTransaction" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "TransactionType", + "snippet": [ + " type TransactionType = TransactionType;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context_interface", + "transaction", + "transaction_type", + "TransactionType" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "AccessList", + "snippet": [ + " type AccessList = ::AccessList;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": "Associated" + } + } + } + }, + { + "name": "Legacy", + "snippet": [ + " type Legacy = Self;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "Eip1559", + "snippet": [ + " type Eip1559 = Self;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "Eip2930", + "snippet": [ + " type Eip2930 = Self;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "Eip4844", + "snippet": [ + " type Eip4844 = Self;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "Eip7702", + "snippet": [ + " type Eip7702 = Self;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "tx_type", + "snippet": [ + " fn tx_type(&self) -> Self::TransactionType {", + " self.tx_type", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": "Associated", + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_context::tx::TxEnv" + }, + { + "InternalString": "tx_type" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "legacy", + "snippet": [ + " fn legacy(&self) -> &Self::Legacy {", + " self", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip2930", + "snippet": [ + " fn eip2930(&self) -> &Self::Eip2930 {", + " self", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip1559", + "snippet": [ + " fn eip1559(&self) -> &Self::Eip1559 {", + " self", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip4844", + "snippet": [ + " fn eip4844(&self) -> &Self::Eip4844 {", + " self", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "eip7702", + "snippet": [ + " fn eip7702(&self) -> &Self::Eip7702 {", + " self", + " }" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_context", + "tx", + "TxEnv" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "common_fields", + "snippet": null, + "kind": "Default" + }, + { + "name": "max_fee", + "snippet": null, + "kind": "Default" + }, + { + "name": "effective_gas_price", + "snippet": null, + "kind": "Default" + }, + { + "name": "kind", + "snippet": null, + "kind": "Default" + }, + { + "name": "access_list", + "snippet": null, + "kind": "Default" + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/context/tx.v b/CoqOfRust/revm/translations/context/tx.v new file mode 100644 index 000000000..f6a16e1e7 --- /dev/null +++ b/CoqOfRust/revm/translations/context/tx.v @@ -0,0 +1,2164 @@ +(* Generated by coq-of-rust *) +Require Import CoqOfRust.CoqOfRust. + +Module tx. + (* StructRecord + { + name := "TxEnv"; + const_params := []; + ty_params := []; + fields := + [ + ("tx_type", + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType"); + ("caller", Ty.path "alloy_primitives::bits::address::Address"); + ("gas_limit", Ty.path "u64"); + ("gas_price", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("transact_to", Ty.path "alloy_primitives::common::TxKind"); + ("value", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + []); + ("data", Ty.path "alloy_primitives::bytes_::Bytes"); + ("nonce", Ty.path "u64"); + ("chain_id", Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ]); + ("access_list", Ty.path "alloy_eip2930::AccessList"); + ("gas_priority_fee", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]); + ("blob_hashes", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ]); + ("max_fee_per_blob_gas", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ]); + ("authorization_list", + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList") + ]; + } *) + + Module Impl_core_clone_Clone_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* Clone *) + Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + Value.StructRecord + "revm_context::tx::TxEnv" + [ + ("tx_type", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "tx_type" + |) + ] + |)); + ("caller", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bits::address::Address", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "caller" + |) + ] + |)); + ("gas_limit", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_limit" + |) + ] + |)); + ("gas_price", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |) + ] + |)); + ("transact_to", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::common::TxKind", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |) + ] + |)); + ("value", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "value" + |) + ] + |)); + ("data", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "data" + |) + ] + |)); + ("nonce", + M.call_closure (| + M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "nonce" + |) + ] + |)); + ("chain_id", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |) + ] + |)); + ("access_list", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "alloy_eip2930::AccessList", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "access_list" + |) + ] + |)); + ("gas_priority_fee", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_priority_fee" + |) + ] + |)); + ("blob_hashes", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "blob_hashes" + |) + ] + |)); + ("max_fee_per_blob_gas", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "max_fee_per_blob_gas" + |) + ] + |)); + ("authorization_list", + M.call_closure (| + M.get_trait_method (| + "core::clone::Clone", + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList", + [], + "clone", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "authorization_list" + |) + ] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::clone::Clone" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("clone", InstanceField.Method clone) ]. + End Impl_core_clone_Clone_for_revm_context_tx_TxEnv. + + Module Impl_core_fmt_Debug_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* Debug *) + Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; f ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let f := M.alloc (| f |) in + M.read (| + let~ names := + M.alloc (| + M.alloc (| + Value.Array + [ + M.read (| Value.String "tx_type" |); + M.read (| Value.String "caller" |); + M.read (| Value.String "gas_limit" |); + M.read (| Value.String "gas_price" |); + M.read (| Value.String "transact_to" |); + M.read (| Value.String "value" |); + M.read (| Value.String "data" |); + M.read (| Value.String "nonce" |); + M.read (| Value.String "chain_id" |); + M.read (| Value.String "access_list" |); + M.read (| Value.String "gas_priority_fee" |); + M.read (| Value.String "blob_hashes" |); + M.read (| Value.String "max_fee_per_blob_gas" |); + M.read (| Value.String "authorization_list" |) + ] + |) + |) in + let~ values := + M.alloc (| + M.alloc (| + Value.Array + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "tx_type" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "caller" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_limit" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "data" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "nonce" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "access_list" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_priority_fee" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "blob_hashes" + |); + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "max_fee_per_blob_gas" + |); + M.alloc (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "authorization_list" + |) + |) + ] + |) + |) in + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Formatter", + "debug_struct_fields_finish", + [] + |), + [ + M.read (| f |); + M.read (| Value.String "TxEnv" |); + M.read (| names |); + M.read (| values |) + ] + |) + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::fmt::Debug" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("fmt", InstanceField.Method fmt) ]. + End Impl_core_fmt_Debug_for_revm_context_tx_TxEnv. + + Module Impl_core_marker_StructuralPartialEq_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + Axiom Implements : + M.IsTraitInstance + "core::marker::StructuralPartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) []. + End Impl_core_marker_StructuralPartialEq_for_revm_context_tx_TxEnv. + + Module Impl_core_cmp_PartialEq_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* PartialEq *) + Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self; other ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + let other := M.alloc (| other |) in + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + LogicalOp.and (| + M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType", + [ + Ty.path + "revm_context_interface::transaction::transaction_type::TransactionType" + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "tx_type" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "tx_type" + |) + ] + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::bits::address::Address", + [ Ty.path "alloy_primitives::bits::address::Address" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "caller" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "caller" + |) + ] + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_limit" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "gas_limit" + |) + |) + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "gas_price" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::common::TxKind", + [ Ty.path "alloy_primitives::common::TxKind" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "transact_to" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [], + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "value" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "value" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_primitives::bytes_::Bytes", + [ Ty.path "alloy_primitives::bytes_::Bytes" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "data" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "data" + |) + ] + |))) + |), + ltac:(M.monadic + (BinOp.eq (| + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "nonce" + |) + |), + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "nonce" + |) + |) + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ], + [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ] ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "chain_id" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "alloy_eip2930::AccessList", + [ Ty.path "alloy_eip2930::AccessList" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "access_list" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "access_list" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ], + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ + Value.Integer IntegerKind.Usize 256; + Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_priority_fee" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "gas_priority_fee" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ], + [ + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "blob_hashes" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "blob_hashes" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + [ + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 + ] + [] + ] + ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "max_fee_per_blob_gas" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "max_fee_per_blob_gas" + |) + ] + |))) + |), + ltac:(M.monadic + (M.call_closure (| + M.get_trait_method (| + "core::cmp::PartialEq", + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList", + [ Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList" ], + "eq", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "authorization_list" + |); + M.SubPointer.get_struct_record_field (| + M.read (| other |), + "revm_context::tx::TxEnv", + "authorization_list" + |) + ] + |))) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::PartialEq" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("eq", InstanceField.Method eq) ]. + End Impl_core_cmp_PartialEq_for_revm_context_tx_TxEnv. + + Module Impl_core_cmp_Eq_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* Eq *) + Definition assert_receiver_is_total_eq + (ε : list Value.t) + (τ : list Ty.t) + (α : list Value.t) + : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun + γ => + ltac:(M.monadic + (M.match_operator (| + Value.DeclaredButUndefined, + [ + fun + γ => + ltac:(M.monadic + (M.alloc (| + Value.Tuple + [] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::cmp::Eq" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ]. + End Impl_core_cmp_Eq_for_revm_context_tx_TxEnv. + + Module Impl_core_default_Default_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn default() -> Self { + Self { + tx_type: TransactionType::Legacy, + caller: Address::default(), + gas_limit: 30_000_000, + gas_price: U256::ZERO, + transact_to: TxKind::Call(Address::default()), + value: U256::ZERO, + data: Bytes::default(), + nonce: 0, + chain_id: Some(1), // Mainnet chain ID is 1 + access_list: AccessList::default(), + gas_priority_fee: Some(U256::ZERO), + blob_hashes: Vec::new(), + max_fee_per_blob_gas: Some(U256::ZERO), + authorization_list: AuthorizationList::default(), + } + } + *) + Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [] => + ltac:(M.monadic + (Value.StructRecord + "revm_context::tx::TxEnv" + [ + ("tx_type", + Value.StructTuple + "revm_context_interface::transaction::transaction_type::TransactionType::Legacy" + []); + ("caller", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "alloy_primitives::bits::address::Address", + [], + "default", + [] + |), + [] + |)); + ("gas_limit", Value.Integer IntegerKind.U64 30000000); + ("gas_price", M.read (| M.get_constant (| "ruint::ZERO" |) |)); + ("transact_to", + Value.StructTuple + "alloy_primitives::common::TxKind::Call" + [ + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "alloy_primitives::bits::address::Address", + [], + "default", + [] + |), + [] + |) + ]); + ("value", M.read (| M.get_constant (| "ruint::ZERO" |) |)); + ("data", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "alloy_primitives::bytes_::Bytes", + [], + "default", + [] + |), + [] + |)); + ("nonce", Value.Integer IntegerKind.U64 0); + ("chain_id", + Value.StructTuple "core::option::Option::Some" [ Value.Integer IntegerKind.U64 1 ]); + ("access_list", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "alloy_eip2930::AccessList", + [], + "default", + [] + |), + [] + |)); + ("gas_priority_fee", + Value.StructTuple + "core::option::Option::Some" + [ M.read (| M.get_constant (| "ruint::ZERO" |) |) ]); + ("blob_hashes", + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ], + "new", + [] + |), + [] + |)); + ("max_fee_per_blob_gas", + Value.StructTuple + "core::option::Option::Some" + [ M.read (| M.get_constant (| "ruint::ZERO" |) |) ]); + ("authorization_list", + M.call_closure (| + M.get_trait_method (| + "core::default::Default", + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList", + [], + "default", + [] + |), + [] + |)) + ])) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "core::default::Default" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("default", InstanceField.Method default) ]. + End Impl_core_default_Default_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_common_CommonTxFields_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn caller(&self) -> Address { + self.caller + } + *) + Definition caller (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "caller" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn gas_limit(&self) -> u64 { + self.gas_limit + } + *) + Definition gas_limit (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_limit" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn value(&self) -> U256 { + self.value + } + *) + Definition value (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "value" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn input(&self) -> &Bytes { + &self.data + } + *) + Definition input (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "data" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn nonce(&self) -> u64 { + self.nonce + } + *) + Definition nonce (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "nonce" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::common::CommonTxFields" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("caller", InstanceField.Method caller); + ("gas_limit", InstanceField.Method gas_limit); + ("value", InstanceField.Method value); + ("input", InstanceField.Method input); + ("nonce", InstanceField.Method nonce) + ]. + End Impl_revm_context_interface_transaction_common_CommonTxFields_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type AccessList = AccessList; *) + Definition _AccessList : Ty.t := Ty.path "alloy_eip2930::AccessList". + + (* + fn chain_id(&self) -> u64 { + self.chain_id.unwrap_or_default() + } + *) + Definition chain_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ], + "unwrap_or_default", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn max_fee_per_gas(&self) -> u128 { + self.gas_price.to() + } + *) + Definition max_fee_per_gas (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "to", + [ Ty.path "u128" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn max_priority_fee_per_gas(&self) -> u128 { + self.gas_priority_fee.unwrap_or_default().to() + } + *) + Definition max_priority_fee_per_gas (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "to", + [ Ty.path "u128" ] + |), + [ + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "unwrap_or_default", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_priority_fee" + |) + |) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn access_list(&self) -> &Self::AccessList { + &self.access_list + } + *) + Definition access_list (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "access_list" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559CommonTxFields" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty _AccessList); + ("chain_id", InstanceField.Method chain_id); + ("max_fee_per_gas", InstanceField.Method max_fee_per_gas); + ("max_priority_fee_per_gas", InstanceField.Method max_priority_fee_per_gas); + ("access_list", InstanceField.Method access_list) + ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559CommonTxFields_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_legacy_LegacyTx_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn kind(&self) -> TxKind { + self.transact_to + } + *) + Definition kind (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn chain_id(&self) -> Option { + self.chain_id + } + *) + Definition chain_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn gas_price(&self) -> u128 { + self.gas_price.try_into().unwrap_or(u128::MAX) + } + *) + Definition gas_price (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::result::Result") + [] + [ + Ty.path "u128"; + Ty.apply (Ty.path "ruint::from::FromUintError") [] [ Ty.path "u128" ] + ], + "unwrap_or", + [] + |), + [ + M.call_closure (| + M.get_trait_method (| + "core::convert::TryInto", + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + [ Ty.path "u128" ], + "try_into", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |) + |) + ] + |); + M.read (| M.get_constant (| "core::num::MAX" |) |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::legacy::LegacyTx" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("kind", InstanceField.Method kind); + ("chain_id", InstanceField.Method chain_id); + ("gas_price", InstanceField.Method gas_price) + ]. + End Impl_revm_context_interface_transaction_legacy_LegacyTx_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type AccessList = AccessList; *) + Definition _AccessList : Ty.t := Ty.path "alloy_eip2930::AccessList". + + (* + fn access_list(&self) -> &Self::AccessList { + &self.access_list + } + *) + Definition access_list (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "access_list" + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn chain_id(&self) -> u64 { + self.chain_id.unwrap_or_default() + } + *) + Definition chain_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ], + "unwrap_or_default", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "chain_id" + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn gas_price(&self) -> u128 { + self.gas_price.to() + } + *) + Definition gas_price (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "to", + [ Ty.path "u128" ] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "gas_price" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn kind(&self) -> TxKind { + self.transact_to + } + *) + Definition kind (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip2930::Eip2930Tx" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("AccessList", InstanceField.Ty _AccessList); + ("access_list", InstanceField.Method access_list); + ("chain_id", InstanceField.Method chain_id); + ("gas_price", InstanceField.Method gas_price); + ("kind", InstanceField.Method kind) + ]. + End Impl_revm_context_interface_transaction_eip2930_Eip2930Tx_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn kind(&self) -> TxKind { + self.transact_to + } + *) + Definition kind (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip1559::Eip1559Tx" + Self + (* Trait polymorphic types *) [] + (* Instance *) [ ("kind", InstanceField.Method kind) ]. + End Impl_revm_context_interface_transaction_eip1559_Eip1559Tx_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn destination(&self) -> Address { + match self.transact_to { + TxKind::Call(addr) => addr, + TxKind::Create => panic!("Create transaction are not allowed in Eip4844"), + } + } + *) + Definition destination (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "alloy_primitives::common::TxKind::Call", + 0 + |) in + let addr := M.copy (| γ0_0 |) in + addr)); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| γ, "alloy_primitives::common::TxKind::Create" |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "Create transaction are not allowed in Eip4844" + |) + ] + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn blob_versioned_hashes(&self) -> &[B256] { + &self.blob_hashes + } + *) + Definition blob_versioned_hashes (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_trait_method (| + "core::ops::deref::Deref", + Ty.apply + (Ty.path "alloc::vec::Vec") + [] + [ + Ty.apply + (Ty.path "alloy_primitives::bits::fixed::FixedBytes") + [ Value.Integer IntegerKind.Usize 32 ] + []; + Ty.path "alloc::alloc::Global" + ], + [], + "deref", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "blob_hashes" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn max_fee_per_blob_gas(&self) -> u128 { + self.max_fee_per_blob_gas.unwrap_or_default().to() + } + *) + Definition max_fee_per_blob_gas (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [], + "to", + [ Ty.path "u128" ] + |), + [ + M.alloc (| + M.call_closure (| + M.get_associated_function (| + Ty.apply + (Ty.path "core::option::Option") + [] + [ + Ty.apply + (Ty.path "ruint::Uint") + [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ] + [] + ], + "unwrap_or_default", + [] + |), + [ + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "max_fee_per_blob_gas" + |) + |) + ] + |) + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip4844::Eip4844Tx" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method destination); + ("blob_versioned_hashes", InstanceField.Method blob_versioned_hashes); + ("max_fee_per_blob_gas", InstanceField.Method max_fee_per_blob_gas) + ]. + End Impl_revm_context_interface_transaction_eip4844_Eip4844Tx_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn destination(&self) -> Address { + match self.transact_to { + TxKind::Call(addr) => addr, + TxKind::Create => panic!("Create transaction are not allowed in Eip7702"), + } + } + *) + Definition destination (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.match_operator (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "transact_to" + |), + [ + fun γ => + ltac:(M.monadic + (let γ0_0 := + M.SubPointer.get_struct_tuple_field (| + γ, + "alloy_primitives::common::TxKind::Call", + 0 + |) in + let addr := M.copy (| γ0_0 |) in + addr)); + fun γ => + ltac:(M.monadic + (let _ := + M.is_struct_tuple (| γ, "alloy_primitives::common::TxKind::Create" |) in + M.alloc (| + M.never_to_any (| + M.call_closure (| + M.get_function (| "core::panicking::panic_fmt", [] |), + [ + M.call_closure (| + M.get_associated_function (| + Ty.path "core::fmt::Arguments", + "new_const", + [] + |), + [ + M.alloc (| + Value.Array + [ + M.read (| + Value.String "Create transaction are not allowed in Eip7702" + |) + ] + |) + ] + |) + ] + |) + |) + |))) + ] + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn authorization_list_len(&self) -> usize { + self.authorization_list.len() + } + *) + Definition authorization_list_len (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList", + "len", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "authorization_list" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn authorization_list_iter(&self) -> impl Iterator { + self.authorization_list.recovered_iter() + } + *) + Definition authorization_list_iter (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.call_closure (| + M.get_associated_function (| + Ty.path "revm_specification::eip7702::authorization_list::AuthorizationList", + "recovered_iter", + [] + |), + [ + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "authorization_list" + |) + ] + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::eip7702::Eip7702Tx" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("destination", InstanceField.Method destination); + ("authorization_list_len", InstanceField.Method authorization_list_len); + ("authorization_list_iter", InstanceField.Method authorization_list_iter) + ]. + End Impl_revm_context_interface_transaction_eip7702_Eip7702Tx_for_revm_context_tx_TxEnv. + + Module Impl_revm_context_interface_transaction_Transaction_for_revm_context_tx_TxEnv. + Definition Self : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type TransactionError = InvalidTransaction; *) + Definition _TransactionError : Ty.t := + Ty.path "revm_context_interface::result::InvalidTransaction". + + (* type TransactionType = TransactionType; *) + Definition _TransactionType : Ty.t := + Ty.path "revm_context_interface::transaction::transaction_type::TransactionType". + + (* type AccessList = ::AccessList; *) + Definition _AccessList : Ty.t := Ty.associated. + + (* type Legacy = Self; *) + Definition _Legacy : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type Eip1559 = Self; *) + Definition _Eip1559 : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type Eip2930 = Self; *) + Definition _Eip2930 : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type Eip4844 = Self; *) + Definition _Eip4844 : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* type Eip7702 = Self; *) + Definition _Eip7702 : Ty.t := Ty.path "revm_context::tx::TxEnv". + + (* + fn tx_type(&self) -> Self::TransactionType { + self.tx_type + } + *) + Definition tx_type (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| + M.SubPointer.get_struct_record_field (| + M.read (| self |), + "revm_context::tx::TxEnv", + "tx_type" + |) + |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn legacy(&self) -> &Self::Legacy { + self + } + *) + Definition legacy (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| self |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn eip2930(&self) -> &Self::Eip2930 { + self + } + *) + Definition eip2930 (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| self |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn eip1559(&self) -> &Self::Eip1559 { + self + } + *) + Definition eip1559 (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| self |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn eip4844(&self) -> &Self::Eip4844 { + self + } + *) + Definition eip4844 (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| self |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + (* + fn eip7702(&self) -> &Self::Eip7702 { + self + } + *) + Definition eip7702 (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M := + match ε, τ, α with + | [], [], [ self ] => + ltac:(M.monadic + (let self := M.alloc (| self |) in + M.read (| self |))) + | _, _, _ => M.impossible "wrong number of arguments" + end. + + Axiom Implements : + M.IsTraitInstance + "revm_context_interface::transaction::Transaction" + Self + (* Trait polymorphic types *) [] + (* Instance *) + [ + ("TransactionError", InstanceField.Ty _TransactionError); + ("TransactionType", InstanceField.Ty _TransactionType); + ("AccessList", InstanceField.Ty _AccessList); + ("Legacy", InstanceField.Ty _Legacy); + ("Eip1559", InstanceField.Ty _Eip1559); + ("Eip2930", InstanceField.Ty _Eip2930); + ("Eip4844", InstanceField.Ty _Eip4844); + ("Eip7702", InstanceField.Ty _Eip7702); + ("tx_type", InstanceField.Method tx_type); + ("legacy", InstanceField.Method legacy); + ("eip2930", InstanceField.Method eip2930); + ("eip1559", InstanceField.Method eip1559); + ("eip4844", InstanceField.Method eip4844); + ("eip7702", InstanceField.Method eip7702) + ]. + End Impl_revm_context_interface_transaction_Transaction_for_revm_context_tx_TxEnv. +End tx. diff --git a/CoqOfRust/revm/translations/specification/constants.json b/CoqOfRust/revm/translations/specification/constants.json new file mode 100644 index 000000000..ec5f60cf5 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/constants.json @@ -0,0 +1,147 @@ +[ + { + "file_name": "crates/specification/src/constants.rs", + "item": { + "Module": { + "name": "constants", + "body": [ + { + "file_name": "crates/specification/src/constants.rs", + "item": { + "Const": { + "name": "value_STACK_LIMIT", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 1024 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/constants.rs", + "item": { + "Const": { + "name": "value_MAX_CODE_SIZE", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 24576 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/constants.rs", + "item": { + "Const": { + "name": "value_MAX_INITCODE_SIZE", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 2 + } + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "constants", + "MAX_CODE_SIZE" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/constants.rs", + "item": { + "Const": { + "name": "value_CALL_STACK_LIMIT", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1024 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip170.json b/CoqOfRust/revm/translations/specification/eip170.json new file mode 100644 index 000000000..9790e78b3 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip170.json @@ -0,0 +1,39 @@ +[ + { + "file_name": "crates/specification/src/eip170.rs", + "item": { + "Module": { + "name": "eip170", + "body": [ + { + "file_name": "crates/specification/src/eip170.rs", + "item": { + "Const": { + "name": "value_MAX_CODE_SIZE", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 24576 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip2.json b/CoqOfRust/revm/translations/specification/eip2.json new file mode 100644 index 000000000..e1d29a936 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip2.json @@ -0,0 +1,371 @@ +[ + { + "file_name": "crates/specification/src/eip2.rs", + "item": { + "Module": { + "name": "eip2", + "body": [ + { + "file_name": "crates/specification/src/eip2.rs", + "item": { + "Const": { + "name": "value_SECP256K1N_HALF", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "ruint", + "Uint" + ] + } + }, + "consts": [ + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 256 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 4 + } + } + } + ], + "tys": [] + } + }, + "func": "from_be_bytes", + "generic_tys": [] + } + }, + "args": [ + { + "Array": { + "elements": [ + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 127 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 93 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 87 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 110 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 115 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 87 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 164 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 80 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 29 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 223 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 233 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 47 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 70 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 104 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 27 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 32 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 160 + } + } + } + ], + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip4844.json b/CoqOfRust/revm/translations/specification/eip4844.json new file mode 100644 index 000000000..7651c9a05 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip4844.json @@ -0,0 +1,344 @@ +[ + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Module": { + "name": "eip4844", + "body": [ + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_GAS_PER_BLOB", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.shl" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + }, + { + "Literal": { + "Integer": { + "kind": "I32", + "negative_sign": false, + "value": 17 + } + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_TARGET_BLOB_NUMBER_PER_BLOCK", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 3 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_MAX_BLOB_NUMBER_PER_BLOCK", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 2 + } + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "TARGET_BLOB_NUMBER_PER_BLOCK" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_MAX_BLOB_GAS_PER_BLOCK", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "MAX_BLOB_NUMBER_PER_BLOCK" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "GAS_PER_BLOB" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_TARGET_BLOB_GAS_PER_BLOCK", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.Wrap.mul" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "TARGET_BLOB_NUMBER_PER_BLOCK" + ] + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "GetConst": [ + "revm_specification", + "eip4844", + "GAS_PER_BLOB" + ] + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_MIN_BLOB_GASPRICE", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_BLOB_GASPRICE_UPDATE_FRACTION", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 3338477 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip4844.rs", + "item": { + "Const": { + "name": "value_VERSIONED_HASH_VERSION_KZG", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip7702/authorization_list.json b/CoqOfRust/revm/translations/specification/eip7702/authorization_list.json new file mode 100644 index 000000000..dc2e4824d --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip7702/authorization_list.json @@ -0,0 +1,7836 @@ +[ + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "Module": { + "name": "eip7702", + "body": [ + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "Module": { + "name": "authorization_list", + "body": [ + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TypeEnum": { + "name": "AuthorizationList", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "Signed", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "discriminant": null + }, + { + "name": "Recovered", + "item": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Signed" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Recovered" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_0" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Signed" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_tuple_field1_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Recovered" + } + } + ], + "kind": "Effectful" + } + }, + { + "LocalVar": "__self_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "rhs": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalInteger": 1 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_0" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__self_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ0_1", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ0_1" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ2_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ0_1" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ2_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_0" + }, + { + "LocalVar": "__arg1_0" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.never_to_any" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "unreachable" + ], + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + " fn default() -> Self {", + " Self::Signed(Vec::new())", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Signed" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(signed: Vec) -> Self {", + " Self::Signed(signed)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "signed", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Signed" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(recovered: Vec) -> Self {", + " Self::Recovered(recovered)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "recovered", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "recovered", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "recovered" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Recovered" + ], + "fields": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "recovered" + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "len", + "snippet": [ + " pub fn len(&self) -> usize {", + " match self {", + " Self::Signed(signed) => signed.len(),", + " Self::Recovered(recovered) => recovered.len(),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "usize" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "recovered", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "recovered" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "empty", + "snippet": [ + " pub fn empty() -> Self {", + " Self::Recovered(Vec::new())", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Recovered" + ], + "fields": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [], + "kind": "Closure" + } + } + ] + } + } + } + } + } + } + }, + { + "name": "is_empty", + "snippet": [ + " pub fn is_empty(&self) -> bool {", + " self.len() == 0", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "len", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Literal": { + "Integer": { + "kind": "Usize", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "recovered_iter", + "snippet": [ + " pub fn recovered_iter<'a>(&'a self) -> Box + 'a> {", + " match self {", + " Self::Signed(signed) => Box::new(signed.iter().map(|signed| signed.clone().into())),", + " Self::Recovered(recovered) => Box::new(recovered.clone().into_iter()),", + " }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Dyn": { + "traits": [ + [ + "core", + "iter", + "traits", + "iterator", + "Iterator", + "Trait" + ] + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "map", + "Map" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "slice", + "iter", + "Iter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "map", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "slice" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "γ1_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Recovered" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "recovered", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "γ1_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "boxed", + "Box" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "new", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "recovered" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "into_recovered", + "snippet": [ + " pub fn into_recovered(self) -> Self {", + " let Self::Signed(signed) = self else {", + " return self;", + " };", + " Self::Recovered(signed.into_iter().map(|signed| signed.into()).collect())", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ0_0", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_tuple_field" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::AuthorizationList::Signed" + }, + { + "InternalInteger": 0 + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ0_0" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "AuthorizationList", + "Recovered" + ], + "fields": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "iter", + "adapters", + "map", + "Map" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + ] + } + }, + "trait_tys": [], + "method_name": "collect", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "iterator", + "Iterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "into_iter", + "IntoIter" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "map", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Function": { + "args": [ + { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "ret": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "iter", + "traits", + "collect", + "IntoIterator" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "vec", + "Vec" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloc", + "alloc", + "Global" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "into_iter", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + { + "Lambda": { + "args": [ + [ + "α0", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + ], + "body": { + "Match": { + "scrutinee": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "α0" + } + ], + "kind": "Effectful" + } + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "signed", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "Into" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "into", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": false, + "is_internal": false + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TypeEnum": { + "name": "InvalidAuthorization", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "InvalidChainId", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "InvalidYParity", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "Eip2InvalidSValue", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidChainId" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidYParity" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "InvalidYParity" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::Eip2InvalidSValue" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Eip2InvalidSValue" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization", + "InvalidChainId" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidYParity" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization", + "InvalidYParity" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::Eip2InvalidSValue" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization", + "Eip2InvalidSValue" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "isize" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/authorization_list.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Display" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + " fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {", + " let s = match self {", + " Self::InvalidChainId => \"Invalid chain_id, Expect chain's ID or zero\",", + " Self::InvalidYParity => \"Invalid y_parity, Expect 0 or 1.\",", + " Self::Eip2InvalidSValue => \"Invalid signature s-value.\",", + " };", + " f.write_str(s)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "authorization_list", + "InvalidAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "s", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.copy" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidChainId" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Literal": { + "String": "Invalid chain_id, Expect chain's ID or zero" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::InvalidYParity" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Invalid y_parity, Expect 0 or 1." + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::eip7702::authorization_list::InvalidAuthorization::Eip2InvalidSValue" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "Invalid signature s-value." + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "s" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip7702/constants.json b/CoqOfRust/revm/translations/specification/eip7702/constants.json new file mode 100644 index 000000000..e0d1397bc --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip7702/constants.json @@ -0,0 +1,76 @@ +[ + { + "file_name": "crates/specification/src/eip7702/constants.rs", + "item": { + "Module": { + "name": "eip7702", + "body": [ + { + "file_name": "crates/specification/src/eip7702/constants.rs", + "item": { + "Module": { + "name": "constants", + "body": [ + { + "file_name": "crates/specification/src/eip7702/constants.rs", + "item": { + "Const": { + "name": "value_PER_AUTH_BASE_COST", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 2500 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + }, + { + "file_name": "crates/specification/src/eip7702/constants.rs", + "item": { + "Const": { + "name": "value_PER_EMPTY_ACCOUNT_COST", + "value": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Literal": { + "Integer": { + "kind": "U64", + "negative_sign": false, + "value": 25000 + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/eip7702/recovered_authorization.json b/CoqOfRust/revm/translations/specification/eip7702/recovered_authorization.json new file mode 100644 index 000000000..a1b9b80f7 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/eip7702/recovered_authorization.json @@ -0,0 +1,2931 @@ +[ + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "Module": { + "name": "eip7702", + "body": [ + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "Module": { + "name": "recovered_authorization", + "body": [ + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TypeStructStruct": { + "name": "RecoveredAuthorization", + "const_params": [], + "ty_params": [], + "fields": [ + [ + "inner", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + [ + "authority", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "debug_struct_field2_finish", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "RecoveredAuthorization" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "inner" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "authority" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ], + "fields": [ + [ + "inner", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + [ + "authority", + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "clone", + "Clone" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "clone", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": null, + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Match": { + "scrutinee": { + "LocalVar": "Value.DeclaredButUndefined" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Tuple": { + "elements": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "LogicalOperator": { + "name": "LogicalOp.and", + "lhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + }, + "rhs": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialEq" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ], + "method_name": "eq", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "new_unchecked", + "snippet": [ + " pub const fn new_unchecked(inner: SignedAuthorization, authority: Option
) -> Self {", + " Self { inner, authority }", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "inner", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "authority", + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "inner", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "inner" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "authority", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "authority" + } + ], + "kind": "Effectful" + } + }, + "body": { + "StructStruct": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ], + "fields": [ + [ + "inner", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "inner" + } + ], + "kind": "Effectful" + } + } + ], + [ + "authority", + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "authority" + } + ], + "kind": "Effectful" + } + } + ] + ], + "base": null + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "inner", + "snippet": [ + " pub fn inner(&self) -> &SignedAuthorization {", + " &self.inner", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "authority", + "snippet": [ + " pub const fn authority(&self) -> Option
{", + " self.authority", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + }, + { + "name": "into_parts", + "snippet": [ + " pub const fn into_parts(self) -> (SignedAuthorization, Option
) {", + " (self.inner, self.authority)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "LocalVar": "self" + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ] + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(signed_auth: SignedAuthorization) -> Self {", + " let authority = signed_auth.recover_authority().ok();", + " Self::new_unchecked(signed_auth, authority)", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "signed_auth", + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "signed_auth", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "signed_auth" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "authority", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "bits", + "address", + "Address" + ] + } + }, + "consts": [], + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_primitives", + "signature", + "error", + "SignatureError" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "func": "ok", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "recover_authority", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "signed_auth" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_unchecked", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "signed_auth" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "authority" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/eip7702/recovered_authorization.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "ops", + "deref", + "Deref" + ], + "trait_ty_params": [], + "items": [ + { + "name": "Target", + "snippet": [ + " type Target = Authorization;" + ], + "kind": { + "RequiredValue": { + "Type": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "Authorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + } + } + }, + { + "name": "deref", + "snippet": [ + " fn deref(&self) -> &Self::Target {", + " &self.inner", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "eip7702", + "recovered_authorization", + "RecoveredAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + "Associated" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "ops", + "deref", + "Deref" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "alloy_eip7702", + "auth_list", + "SignedAuthorization" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "trait_tys": [], + "method_name": "deref", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.SubPointer.get_struct_record_field" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + { + "InternalString": "revm_specification::eip7702::recovered_authorization::RecoveredAuthorization" + }, + { + "InternalString": "inner" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file diff --git a/CoqOfRust/revm/translations/specification/hardfork.json b/CoqOfRust/revm/translations/specification/hardfork.json new file mode 100644 index 000000000..ce3b685a6 --- /dev/null +++ b/CoqOfRust/revm/translations/specification/hardfork.json @@ -0,0 +1,9542 @@ +[ + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Module": { + "name": "hardfork", + "body": [ + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TypeEnum": { + "name": "SpecId", + "const_params": [], + "ty_params": [], + "variants": [ + { + "name": "FRONTIER", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": 0 + }, + { + "name": "FRONTIER_THAWING", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "HOMESTEAD", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "DAO_FORK", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "TANGERINE", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "SPURIOUS_DRAGON", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "BYZANTIUM", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CONSTANTINOPLE", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "PETERSBURG", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "ISTANBUL", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "MUIR_GLACIER", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "BERLIN", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "LONDON", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "ARROW_GLACIER", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "GRAY_GLACIER", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "MERGE", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "SHANGHAI", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "CANCUN", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "PRAGUE", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "OSAKA", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + }, + { + "name": "LATEST", + "item": { + "Tuple": { + "tys": [] + } + }, + "discriminant": null + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "clone", + "Clone" + ], + "trait_ty_params": [], + "items": [ + { + "name": "clone", + "snippet": [ + "Clone" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + }, + { + "name": "clone_from", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "Copy" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Debug" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + "Debug" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_str", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "self" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::FRONTIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "FRONTIER" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::FRONTIER_THAWING" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "FRONTIER_THAWING" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::HOMESTEAD" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "HOMESTEAD" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::DAO_FORK" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "DAO_FORK" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::TANGERINE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "TANGERINE" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::SPURIOUS_DRAGON" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SPURIOUS_DRAGON" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::BYZANTIUM" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BYZANTIUM" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::CONSTANTINOPLE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CONSTANTINOPLE" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::PETERSBURG" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "PETERSBURG" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::ISTANBUL" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "ISTANBUL" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::MUIR_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "MUIR_GLACIER" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::BERLIN" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "BERLIN" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::LONDON" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "LONDON" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::ARROW_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "ARROW_GLACIER" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::GRAY_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "GRAY_GLACIER" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::MERGE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "MERGE" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::SHANGHAI" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "SHANGHAI" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::CANCUN" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "CANCUN" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::PRAGUE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "PRAGUE" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::OSAKA" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "OSAKA" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": "γ", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::LATEST" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "LATEST" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "default", + "Default" + ], + "trait_ty_params": [], + "items": [ + { + "name": "default", + "snippet": [ + "Default" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "marker", + "StructuralPartialEq" + ], + "trait_ty_params": [], + "items": [] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialEq" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "eq", + "snippet": [ + "PartialEq" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "BinOp.eq" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__self_discr" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "ne", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Eq" + ], + "trait_ty_params": [], + "items": [ + { + "name": "assert_receiver_is_total_eq", + "snippet": [ + "Eq" + ], + "kind": { + "OptionalValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Tuple": { + "elements": [] + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "PartialOrd" + ], + "trait_ty_params": [ + [ + "Rhs", + "Default" + ] + ], + "items": [ + { + "name": "partial_cmp", + "snippet": [ + "PartialOrd" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "cmp", + "Ordering" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "PartialOrd" + ], + "self_ty": { + "Path": { + "path": [ + "u8" + ] + } + }, + "trait_tys": [ + { + "Path": { + "path": [ + "u8" + ] + } + } + ], + "method_name": "partial_cmp", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "lt", + "snippet": null, + "kind": "Default" + }, + { + "name": "le", + "snippet": null, + "kind": "Default" + }, + { + "name": "gt", + "snippet": null, + "kind": "Default" + }, + { + "name": "ge", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "cmp", + "Ord" + ], + "trait_ty_params": [], + "items": [ + { + "name": "cmp", + "snippet": [ + "Ord" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "cmp", + "Ordering" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "__arg1_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "cmp", + "Ord" + ], + "self_ty": { + "Path": { + "path": [ + "u8" + ] + } + }, + "trait_tys": [], + "method_name": "cmp", + "generic_tys": [] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "LocalVar": "__arg1_discr" + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "max", + "snippet": null, + "kind": "Default" + }, + { + "name": "min", + "snippet": null, + "kind": "Default" + }, + { + "name": "clamp", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "hash", + "Hash" + ], + "trait_ty_params": [], + "items": [ + { + "name": "hash", + "snippet": [ + "Hash" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [ + "__H" + ], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "state", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Tuple": { + "tys": [] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "state", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Let": { + "name": "__self_discr", + "is_user": true, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetFunction": { + "func": [ + "core", + "intrinsics", + "discriminant_value" + ], + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "hash", + "Hash" + ], + "self_ty": { + "Path": { + "path": [ + "u8" + ] + } + }, + "trait_tys": [], + "method_name": "hash", + "generic_tys": [ + { + "Var": { + "name": "__H" + } + } + ] + } + }, + "args": [ + { + "LocalVar": "__self_discr" + }, + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "state" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + }, + { + "name": "hash_slice", + "snippet": null, + "kind": "Default" + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "n", + "snippet": [ + "enumn::N" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "value", + { + "Path": { + "path": [ + "u8" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "value", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "value" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "value" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 0 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "FRONTIER" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 1 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "FRONTIER_THAWING" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 2 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "HOMESTEAD" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 3 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "DAO_FORK" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 4 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "TANGERINE" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 5 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SPURIOUS_DRAGON" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 6 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "BYZANTIUM" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 7 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "CONSTANTINOPLE" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 8 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "PETERSBURG" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 9 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "ISTANBUL" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 10 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "MUIR_GLACIER" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 11 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "BERLIN" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 12 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LONDON" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 13 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "ARROW_GLACIER" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 14 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "GRAY_GLACIER" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 15 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "MERGE" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 16 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SHANGHAI" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 17 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "CANCUN" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 18 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "PRAGUE" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 19 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "OSAKA" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "Integer": { + "kind": "U8", + "negative_sign": false, + "value": 255 + } + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "Some" + ], + "fields": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "core", + "option", + "Option", + "None" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Impl": { + "generic_consts": [], + "generic_tys": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "items": [ + { + "name": "try_from_u8", + "snippet": [ + " pub fn try_from_u8(spec_id: u8) -> Option {", + " Self::n(spec_id)", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "spec_id", + { + "Path": { + "path": [ + "u8" + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "option", + "Option" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "spec_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "n", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + }, + { + "name": "is_enabled_in", + "snippet": [ + " pub const fn is_enabled_in(self, other: Self) -> bool {", + " self as u8 >= other as u8", + " }" + ], + "kind": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ], + [ + "other", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Path": { + "path": [ + "bool" + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "other", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "BinOp.ge" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Pure" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.rust_cast" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "other" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Pure" + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Module": { + "name": "name", + "body": [ + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_FRONTIER", + "value": { + "Literal": { + "String": "Frontier" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_FRONTIER_THAWING", + "value": { + "Literal": { + "String": "Frontier Thawing" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_HOMESTEAD", + "value": { + "Literal": { + "String": "Homestead" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_DAO_FORK", + "value": { + "Literal": { + "String": "DAO Fork" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_TANGERINE", + "value": { + "Literal": { + "String": "Tangerine" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_SPURIOUS_DRAGON", + "value": { + "Literal": { + "String": "Spurious" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_BYZANTIUM", + "value": { + "Literal": { + "String": "Byzantium" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_CONSTANTINOPLE", + "value": { + "Literal": { + "String": "Constantinople" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_PETERSBURG", + "value": { + "Literal": { + "String": "Petersburg" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_ISTANBUL", + "value": { + "Literal": { + "String": "Istanbul" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_MUIR_GLACIER", + "value": { + "Literal": { + "String": "MuirGlacier" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_BERLIN", + "value": { + "Literal": { + "String": "Berlin" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_LONDON", + "value": { + "Literal": { + "String": "London" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_ARROW_GLACIER", + "value": { + "Literal": { + "String": "Arrow Glacier" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_GRAY_GLACIER", + "value": { + "Literal": { + "String": "Gray Glacier" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_MERGE", + "value": { + "Literal": { + "String": "Merge" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_SHANGHAI", + "value": { + "Literal": { + "String": "Shanghai" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_CANCUN", + "value": { + "Literal": { + "String": "Cancun" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_PRAGUE", + "value": { + "Literal": { + "String": "Prague" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_OSAKA", + "value": { + "Literal": { + "String": "PragueEOF" + } + } + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "Const": { + "name": "value_LATEST", + "value": { + "Literal": { + "String": "Latest" + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(name: &str) -> Self {", + " match name {", + " name::FRONTIER => Self::FRONTIER,", + " name::FRONTIER_THAWING => Self::FRONTIER_THAWING,", + " name::HOMESTEAD => Self::HOMESTEAD,", + " name::DAO_FORK => Self::DAO_FORK,", + " name::TANGERINE => Self::TANGERINE,", + " name::SPURIOUS_DRAGON => Self::SPURIOUS_DRAGON,", + " name::BYZANTIUM => Self::BYZANTIUM,", + " name::CONSTANTINOPLE => Self::CONSTANTINOPLE,", + " name::PETERSBURG => Self::PETERSBURG,", + " name::ISTANBUL => Self::ISTANBUL,", + " name::MUIR_GLACIER => Self::MUIR_GLACIER,", + " name::BERLIN => Self::BERLIN,", + " name::LONDON => Self::LONDON,", + " name::ARROW_GLACIER => Self::ARROW_GLACIER,", + " name::GRAY_GLACIER => Self::GRAY_GLACIER,", + " name::MERGE => Self::MERGE,", + " name::SHANGHAI => Self::SHANGHAI,", + " name::CANCUN => Self::CANCUN,", + " name::PRAGUE => Self::PRAGUE,", + " name::OSAKA => Self::OSAKA,", + " name::LATEST => Self::LATEST,", + " _ => Self::LATEST,", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "name", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "body": { + "Let": { + "name": "name", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "name" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "name" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Frontier" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "FRONTIER" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Frontier Thawing" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "FRONTIER_THAWING" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Homestead" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "HOMESTEAD" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "DAO Fork" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "DAO_FORK" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Tangerine" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "TANGERINE" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Spurious" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SPURIOUS_DRAGON" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Byzantium" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "BYZANTIUM" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Constantinople" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "CONSTANTINOPLE" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Petersburg" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "PETERSBURG" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Istanbul" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "ISTANBUL" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "MuirGlacier" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "MUIR_GLACIER" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Berlin" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "BERLIN" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "London" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LONDON" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Arrow Glacier" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "ARROW_GLACIER" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Gray Glacier" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "GRAY_GLACIER" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Merge" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "MERGE" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Shanghai" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "SHANGHAI" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Cancun" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "CANCUN" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Prague" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "PRAGUE" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "PragueEOF" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "OSAKA" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_constant_or_break_match" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "γ" + } + ], + "kind": "Effectful" + } + }, + { + "Literal": { + "String": "Latest" + } + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "StructTuple": { + "path": [ + "revm_specification", + "hardfork", + "SpecId", + "LATEST" + ], + "fields": [] + } + } + ], + "kind": "Effectful" + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + }, + "of_trait": [ + "core", + "convert", + "From" + ], + "trait_ty_params": [ + [ + "T", + { + "RequiredValue": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + } + ] + ], + "items": [ + { + "name": "from", + "snippet": [ + " fn from(spec_id: SpecId) -> Self {", + " match spec_id {", + " SpecId::FRONTIER => name::FRONTIER,", + " SpecId::FRONTIER_THAWING => name::FRONTIER_THAWING,", + " SpecId::HOMESTEAD => name::HOMESTEAD,", + " SpecId::DAO_FORK => name::DAO_FORK,", + " SpecId::TANGERINE => name::TANGERINE,", + " SpecId::SPURIOUS_DRAGON => name::SPURIOUS_DRAGON,", + " SpecId::BYZANTIUM => name::BYZANTIUM,", + " SpecId::CONSTANTINOPLE => name::CONSTANTINOPLE,", + " SpecId::PETERSBURG => name::PETERSBURG,", + " SpecId::ISTANBUL => name::ISTANBUL,", + " SpecId::MUIR_GLACIER => name::MUIR_GLACIER,", + " SpecId::BERLIN => name::BERLIN,", + " SpecId::LONDON => name::LONDON,", + " SpecId::ARROW_GLACIER => name::ARROW_GLACIER,", + " SpecId::GRAY_GLACIER => name::GRAY_GLACIER,", + " SpecId::MERGE => name::MERGE,", + " SpecId::SHANGHAI => name::SHANGHAI,", + " SpecId::CANCUN => name::CANCUN,", + " SpecId::PRAGUE => name::PRAGUE,", + " SpecId::OSAKA => name::OSAKA,", + " SpecId::LATEST => name::LATEST,", + " }", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "spec_id", + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + }, + "body": { + "Let": { + "name": "spec_id", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "spec_id" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Match": { + "scrutinee": { + "LocalVar": "spec_id" + }, + "arms": [ + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::FRONTIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "FRONTIER" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::FRONTIER_THAWING" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "FRONTIER_THAWING" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::HOMESTEAD" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "HOMESTEAD" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::DAO_FORK" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "DAO_FORK" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::TANGERINE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "TANGERINE" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::SPURIOUS_DRAGON" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "SPURIOUS_DRAGON" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::BYZANTIUM" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "BYZANTIUM" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::CONSTANTINOPLE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "CONSTANTINOPLE" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::PETERSBURG" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "PETERSBURG" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::ISTANBUL" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "ISTANBUL" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::MUIR_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "MUIR_GLACIER" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::BERLIN" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "BERLIN" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::LONDON" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "LONDON" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::ARROW_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "ARROW_GLACIER" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::GRAY_GLACIER" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "GRAY_GLACIER" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::MERGE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "MERGE" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::SHANGHAI" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "SHANGHAI" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::CANCUN" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "CANCUN" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::PRAGUE" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "PRAGUE" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::OSAKA" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "OSAKA" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + }, + { + "Lambda": { + "args": [ + [ + "γ", + null + ] + ], + "body": { + "Let": { + "name": null, + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.is_struct_tuple" + }, + "args": [ + { + "LocalVar": "γ" + }, + { + "InternalString": "revm_specification::hardfork::SpecId::LATEST" + } + ], + "kind": "Effectful" + } + }, + "body": { + "GetConst": [ + "revm_specification", + "hardfork", + "name", + "LATEST" + ] + } + } + }, + "is_for_match": true, + "is_internal": true + } + } + ] + } + } + ], + "kind": "Effectful" + } + } + } + } + } + } + } + } + } + } + ] + } + } + }, + { + "file_name": "crates/specification/src/hardfork.rs", + "item": { + "TraitImpl": { + "generic_consts": [], + "generic_tys": [], + "predicates": [], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "of_trait": [ + "core", + "fmt", + "Display" + ], + "trait_ty_params": [], + "items": [ + { + "name": "fmt", + "snippet": [ + " fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {", + " write!(f, \"{}\", <&'static str>::from(*self))", + " }" + ], + "kind": { + "RequiredValue": { + "Definition": { + "definition": { + "const_params": [], + "ty_params": [], + "signature_and_body": { + "args": [ + [ + "self", + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ], + [ + "f", + { + "Application": { + "func": { + "Path": { + "path": [ + "&mut" + ] + } + }, + "consts": [], + "tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + null + ] + ], + "ret_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "result", + "Result" + ] + } + }, + "consts": [], + "tys": [ + { + "Tuple": { + "tys": [] + } + }, + { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Error" + ] + } + }, + "consts": [], + "tys": [] + } + } + ] + } + }, + "body": { + "Let": { + "name": "self", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Let": { + "name": "f", + "is_user": false, + "init": { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + "body": { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Formatter" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "write_fmt", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "f" + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "Arguments" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_v1", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Literal": { + "String": "" + } + } + ], + "kind": "Effectful" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + }, + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Array": { + "elements": [ + { + "Call": { + "func": { + "GetAssociatedFunction": { + "ty": { + "Application": { + "func": { + "Path": { + "path": [ + "core", + "fmt", + "rt", + "Argument" + ] + } + }, + "consts": [], + "tys": [] + } + }, + "func": "new_display", + "generic_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + } + ] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.alloc" + }, + "args": [ + { + "Call": { + "func": { + "GetTraitMethod": { + "trait_name": [ + "core", + "convert", + "From" + ], + "self_ty": { + "Application": { + "func": { + "Path": { + "path": [ + "&" + ] + } + }, + "consts": [], + "tys": [ + { + "Path": { + "path": [ + "str" + ] + } + } + ] + } + }, + "trait_tys": [ + { + "Application": { + "func": { + "Path": { + "path": [ + "revm_specification", + "hardfork", + "SpecId" + ] + } + }, + "consts": [], + "tys": [] + } + } + ], + "method_name": "from", + "generic_tys": [] + } + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "Call": { + "func": { + "LocalVar": "M.read" + }, + "args": [ + { + "LocalVar": "self" + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "is_internal": false + } + } + ], + "kind": "Effectful" + } + } + ], + "kind": "Closure" + } + } + ], + "kind": "Closure" + } + } + } + } + } + } + } + } + } + } + } + } + ] + } + } + } + ] + } + } + } +] \ No newline at end of file